Overloading >>

**anon** · 05-06-2008

On further though, operator >> for string returns an istream&. The overload for your Car class expects a more specific derived class ifstream. Not all istreams are ifstreams, so there's a mismatch.

It doesn't matter if you have used an istream before, if you are overloading operator >> use it. This way you can input into Car from files, console and stringstreams all the same.

**h3ro** · 05-07-2008

Im still having problem with this. I changed it to istream, but when I tried to use it in a class that has inheritance im getting some trouble.

Any ideas on how to solve this?

I think the problem is the Car does not have a virtual >> function, as friend functions cant be virtual.

Code:

class Car
{
      friend virtual std::istream  &operator>>(std::istream  &input, Car &c) = 0;  // < ----------- Does not work
      
      public:
             Car(string n = "Defaul");
             
      protected:
              string name;
};

Car::Car(string n)
{
   name = n;
}

class RaceCar : public Car
{
      friend std::istream  &operator>>(std::istream  &input, RaceCar &rc);
      
      public:
             RaceCar(string n = "Defaul", int speed = -1);
             
      private:
              int maxSpeed;
      
};

RaceCar::RaceCar(string n, int speed )
{
   name = n;
   maxSpeed = speed;
}

std::istream &operator>>(std::istream &input, RaceCar &rc)
{
    input >> rc.name >> rc.maxSpeed;
    return input;            
}

int main()
{
    Car *carList[5];
    
    carList[0] = new RaceCar;
    
    ifstream fileData;
    fileData.open("info.txt");
    
    fileData >> carList[0];    // < ----------- Does not work
    
    delete carList[0];

    return 0;    
}

**hk_mp5kpdw** · 05-07-2008

carList[0] is a pointer to an object, not an object itself. Your operator>> reads from a stream into an object, not a pointer to an object.

**laserlight** · 05-07-2008

The overload of operator>> is not a member function (and it cannot be, since you do not control std::istream). Consequently, it cannot a virtual member function, whether pure virtual or otherwise.

What you can do is this:

Code:

class Car
{
public:
    friend std::istream& operator>>(std::istream& in, Car& car)
    {
        car.read(in);
        return in;
    }

    Car(const std::string& n = "Defaul") : name(n) {}
    virtual ~Car() {}
protected:
    std::string name;

    virtual void read(std::istream& in) = 0;
};

class RaceCar : public Car
{
public:
    RaceCar(const std::string& n = "Defaul", int speed = -1)
        : Car(n), maxSpeed(speed) {}

protected:
    virtual void read(std::istream& in)
    {
        in >> name >> maxSpeed;
    }

private:
    int maxSpeed;
};