C++ HW - defining classes - objects that have objects of other class problem in header file (out of scope?), (also redefining operators, read in out)

Question

This is my first time with much of this code. With this instancepool.h file below I get errors saying I can't use vector (line 14) or have instance& as a return type (line 20). It seems it can't use the instance objects despite the fact that I have included them.

#ifndef _INSTANCEPOOL_H
#define _INSTANCEPOOL_H
#include "instance.h"
#include <iostream>
#include <string>
#include <vector>
#include <stdlib.h>
using namespace std;

class InstancePool 
      {
      private:
              unsigned instances;//total number of instance objects
              vector<instance> ipp;//the collection of instance objects, held in a vector
      public:
             InstancePool();//Default constructor. Creates an InstancePool object that contains no Instance objects
             InstancePool(const InstancePool& original);//Copy constructor. After copying, changes to original should not affect the copy that was created.
             ~InstancePool();//Destructor
             unsigned getNumberOfInstances() const;//Returns the number of Instance objects the the InstancePool contains.
             const instance& operator[](unsigned index) const;
             InstancePool& operator=(const InstancePool& right);//Overloading the assignment operator for InstancePool.
             friend istream& operator>>(istream& in, InstancePool& ip);//Overloading of the >> operator. 
             friend ostream& operator<<(ostream& out, const InstancePool& ip);//Overloading of the << operator. 
      };
#endif

Here is the instance.h :

#ifndef _INSTANCE_H
#define _INSTANCE_H
///////////////////////////////#include "instancepool.h"
#include <iostream>
#include <string>
#include <stdlib.h>
using namespace std;

class Instance 
{
      private:
              string filenamee;
              bool categoryy;
              unsigned featuress;

              unsigned* featureIDD;
              unsigned* frequencyy;
              string* featuree;

      public:
             Instance (unsigned features = 0);//default constructor
             unsigned getNumberOfFeatures() const; //Returns the number of the keywords that the calling Instance object can store.
             Instance(const Instance& original);//Copy constructor. After copying, changes to the original should not affect the copy that was created.
             ~Instance() { delete []featureIDD; delete []frequencyy; delete []featuree;}//Destructor.
             void setCategory(bool category){categoryy = category;}//Sets the category of the message. Spam messages are represented with true and and legit messages with false.//easy
             bool getCategory() const;//Returns the category of the message.
             void setFileName(const string& filename){filenamee = filename;}//Stores the name of the file (i.e. “spam/spamsga1.txt”, like in 1st assignment) in which the message was initially stored.//const string& trick?
             string getFileName() const;//Returns the name of the file in which the message was initially stored.
             void setFeature(unsigned i, const string& feature, unsigned featureID,unsigned frequency) {//i for array positions
                  featuree[i] = feature;
                  featureIDD[i] = featureID;
                  frequencyy[i] = frequency;
                  }
             string getFeature(unsigned i) const;//Returns the keyword which is located in the ith position.//const string
             unsigned getFeatureID(unsigned i) const;//Returns the code of the keyword which is located in the ith position.
             unsigned getFrequency(unsigned i) const;//Returns the frequency
             Instance& operator=(const Instance& right);//Overloading of the assignment operator for Instance.
             friend ostream& operator<<(ostream& out, const Instance& inst);//Overloading of the << operator for Instance.
             friend istream& operator>>(istream& in, Instance& inst);//Overloading of the >> operator for Instance. 


};
#endif

Also, if it is helpful here is instance.cpp:

// Here we implement the functions of the class apart from the inline ones

#include "instance.h"
#include <iostream>
#include <string>
#include <stdlib.h>
using namespace std;

      Instance::Instance(unsigned features) {  //Constructor that can be used as the default constructor.
               featuress = features;
               if (features == 0)
                   return;
               featuree = new string[featuress]; // Dynamic memory allocation.
               featureIDD = new unsigned[featuress];
               frequencyy = new unsigned[featuress];  
               return;
               }

      unsigned Instance::getNumberOfFeatures() const {//Returns the number of the keywords that the calling Instance object can store.
               return featuress;}

      Instance::Instance(const Instance& original) {//Copy constructor.
              filenamee = original.filenamee;
              categoryy = original.categoryy;
              featuress = original.featuress;

              featuree = new string[featuress]; 
              for(unsigned i = 0; i < featuress; i++) {
                           featuree[i] = original.featuree[i];
                           }
              featureIDD = new unsigned[featuress];
              for(unsigned i = 0; i < featuress; i++) {
                           featureIDD[i] = original.featureIDD[i];
                           }
              frequencyy = new unsigned[featuress]; 
              for(unsigned i = 0; i < featuress; i++) {
                           frequencyy[i] = original.frequencyy[i];} 
              }

      bool Instance::getCategory() const { //Returns the category of the message.
               return categoryy;}

      string Instance::getFileName() const { //Returns the name of the file in which the message was initially stored.
             return filenamee;}

      string Instance::getFeature(unsigned i) const { //Returns the keyword which is located in the ith position.//const string
             return featuree[i];}

      unsigned Instance::getFeatureID(unsigned i) const { //Returns the code of the keyword which is located in the ith position.
               return featureIDD[i];}

      unsigned Instance::getFrequency(unsigned i) const { //Returns the frequency
               return frequencyy[i];}

      Instance& Instance::operator=(const Instance& right) { //Overloading of the assignment operator for Instance. 
                if(this == &right) return *this;
                delete []featureIDD;
                delete []frequencyy;
                delete []featuree;
                filenamee = right.filenamee;
                categoryy = right.categoryy;
                featuress = right.featuress;
                featureIDD = new unsigned[featuress];
                frequencyy = new unsigned[featuress];
                featuree = new string[featuress];
                for(unsigned i = 0; i < featuress; i++) {
                             featureIDD[i] = right.featureIDD[i]; }
                for(unsigned i = 0; i < featuress; i++) {
                             frequencyy[i] = right.frequencyy[i]; }
                for(unsigned i = 0; i < featuress; i++) {
                             featuree[i] = right.featuree[i]; }
                return *this;
                }

      ostream& operator<<(ostream& out, const Instance& inst) {//Overloading of the << operator for Instance. 
               out << endl << "<message file=" << '"' << inst.filenamee << '"' << " category=";
               if  (inst.categoryy == 0)
                   out << '"' << "legit" << '"';
               else
                   out << '"' << "spam" << '"';
               out << " features=" << '"' << inst.featuress << '"' << ">" <<endl;
               for (int i = 0; i < inst.featuress; i++) {
                   out << "<feature id=" << '"' << inst.featureIDD[i] << '"' << " freq=" << '"' << inst.frequencyy[i] << '"' << "> " << inst.featuree[i] << " </feature>"<< endl;
                   }
               out << "</message>" << endl;
               return out;
               }

      istream& operator>>(istream& in, Instance& inst) { //Overloading of the >> operator for Instance.
               string word;
               string numbers = "";
               string filenamee2 = "";
               bool categoryy2 = 0;
               unsigned featuress2;
               string featuree2;
               unsigned featureIDD2;
               unsigned frequencyy2;
               unsigned i;
               unsigned y;
               while(in >> word) {
                    if (word == "<message") {//if at beginning of message
                       in >> word;//grab filename word
                       for (y=6; word[y]!='"'; y++) {//pull out filename from between quotes
                           filenamee2 += word[y];} 
                       in >> word;//grab category word
                       if (word[10] == 's')
                          categoryy2 = 1;
                       in >> word;//grab features word
                       for (y=10; word[y]!='"'; y++) {
                           numbers += word[y];} 
                       featuress2 = atoi(numbers.c_str());//convert string of numbers to integer
                       Instance tempp2(featuress2);//make a temporary Instance object to hold values read in
                       tempp2.setFileName(filenamee2);//set temp object to filename read in
                       tempp2.setCategory(categoryy2);
                       for (i=0; i<featuress2; i++) {//loop reading in feature reports for message
                           in >> word >> word >> word;//skip two words
                           numbers = "";//reset numbers string
                           for (int y=4; word[y]!='"'; y++) {//grab feature ID
                               numbers += word[y];} 
                           featureIDD2 = atoi(numbers.c_str());
                           in >> word;//
                           numbers = "";
                           for (int y=6; word[y]!='"'; y++) {//grab frequency
                               numbers += word[y];} 
                           frequencyy2 = atoi(numbers.c_str());
                           in >> word;//grab actual feature string
                           featuree2 = word;
                           tempp2.setFeature(i, featuree2, featureIDD2, frequencyy2);
                           }//all done reading in and setting features
                       in >> word;//read in last part of message : </message>
                       inst = tempp2;//set inst (reference) to tempp2 (tempp2 will be destroyed at end of function call)
                       return in;
                       }
                    }
               }

and instancepool.cpp:

// Here we implement the functions of the class apart from the inline ones

#include "instancepool.h"
#include "instance.h"
#include <iostream>
#include <string>
#include <vector>
#include <stdlib.h>
using namespace std;

      InstancePool::InstancePool()//Default constructor. Creates an InstancePool object that contains no Instance objects
            {
            instances = 0;
            ipp.clear();                      
            }

      InstancePool::~InstancePool() {
            ipp.clear();}

      InstancePool::InstancePool(const InstancePool& original) {//Copy constructor. 
            instances = original.instances;
            for (int i = 0; i<instances; i++) {
                ipp.push_back(original.ipp[i]);
                }
            }

      unsigned InstancePool::getNumberOfInstances() const {//Returns the number of Instance objects the the InstancePool contains.
            return instances;}

      const Instance& InstancePool::operator[](unsigned index) const {//Overloading of the [] operator for InstancePool.
            return ipp[index];}

      InstancePool& InstancePool::operator=(const InstancePool& right) {//Overloading the assignment operator for InstancePool.
            if(this == &right) return *this;
                ipp.clear();
                instances = right.instances;
                for(unsigned i = 0; i < instances; i++) {
                             ipp.push_back(right.ipp[i]); }
                return *this;
                }

      istream& operator>>(istream& in, InstancePool& ip) {//Overloading of the >> operator. 
            ip.ipp.clear();
            string word;
            string numbers;
            int total;//int to hold total number of messages in collection
            while(in >> word) {
                     if (word == "<messagecollection"){
                              in >> word;//reads in total number of all messages
                              for (int y=10; word[y]!='"'; y++){
                                  numbers = "";
                                  numbers += word[y];
                                  }
                              total = atoi(numbers.c_str());
                              for (int x = 0; x<total; x++) {//do loop for each message in collection
                                  in >> ip.ipp[x];//use instance friend function and [] operator to fill in values and create Instance objects and read them intot he vector
                                  }
                              }
                     }           
            } 

      ostream& operator<<(ostream& out, const InstancePool& ip) {//Overloading of the << operator. 
            out << "<messagecollection messages=" << '"' << '>' << ip.instances << '"'<< endl << endl;
            for (int z=0; z<ip.instances; z++) {
                out << ip[z];}
            out << endl<<"</messagecollection>\n";
            }

This code is currently not writing to files correctly either at least, I'm sure it has many problems. I hope my posting of so much is not too much, and any help would be very much appreciated. Thanks!

Answer 1

You created an Instance type but are trying to use instance. Case matters.