Overloading >>

Hallo,

I am trying to overload the >> sign, but I cant get it to work. Any one know what is wrong?

Code:

---

class Point
{
      public:
            void operator>>(ifstream &input, const Point &p);
            ...
}

void Point::operator>>(ifstream &input, const Point &p)
{
    input >> p.x >> p.y;
}

---

Quote:

---

declaration of `operator>>' as non-function

---

Thank :)

You can't overload a binary operator like that inside a class. Make it a function outside the class. If it needs access to private internals of Point, then make it a friend.

Just to be clear, you can overload binary operators inside a class, but this one would have to be overloaded inside the ifstream class rather than the Point class because the ifstream is on the left side of the operator. Since you aren't allowed to change ifstream, the solution is to make it a non-member function.

Normally, and operator>> looks like this:

Code:

---

istream& operator>>(istream& input, MyClass& o)
{
  // Do input into o.
  return input;
}

---

Notice that it uses istream instead of ifstream so that it will work on any input stream (like cin or an ifstream). Also notice that it returns input so that you can chain the operator: cin >> point1 >> point2. Finally, notice that the MyClass reference is not const, because you are changing o (or in your case p).

Of course, the other difference is that you often need the operator to be a friend as brewbuck indicated.

Thanks for the replies. I tried both of the things you posted before I created my post, but it did not work...forgot the namespace

Here is what I ended up with

Code:

---

friend std::ifstream &operator>>(std::ifstream &input, Point &p);

---

Should the input be const? I cant see any reasons for it to not be...

>> Should the input be const? I cant see any reasons for it to not be...
You are modifying p by setting x and y to new values.

Also, is there a reason you are choosing to use ifstream instead of istream?

Quote:

---

>> Should the input be const? I cant see any reasons for it to not be...
You are modifying p by setting x and y to new values.

---

I change the point, not the std::ifstream &input, or is that change somehow as well?

Quote:

---

Also, is there a reason you are choosing to use ifstream instead of istream?

---

I have only used ifstream before, so it was easier there and then.

Code:

---

istream& operator>>(istream& input, MyClass& o)
{
  // Do input into o.
  return input;
}

---

Why would you return input?

The way I understand it is like this:
Take input and pass it to >>
Assign value to Point
Return input back to input <--- Does not make sense to me

Where am I wrong?

Thanks for the replies so far.

>> I change the point, not the std::ifstream &input, or is that change somehow as well?
Oh, sorry. Yes, you are changing input as well because the text is being read from the stream and so the stream will be in a different state after you read from it.

>> I have only used ifstream before, so it was easier there and then.
Ok. The reason you use istream is that it is the base class of ifstream and allows you to use your operator with stringstreams or cin. If you are only using ifstreams and don't want to use code you haven't learned then that's fine, just know for the future that istream is the better solution.

>> Why would you return input?
Take code like this:

Code:

---

std::ifstream in("points.txt");
Point p1, p2;

in >> p1 >> p2;

---

That last line is just calling the operator>> function twice. It goes from left to right:

Code:

---

(in >> p1) >> p2;

---

If you change it to function notation it looks like this:

Code:

---

operator>>(operator>>(in, p1), p2);

---

The function in blue is called first. Then the return value of that function is passed to the function in red. You want to pass an input stream as the first parameter to the function in red, which is why the operator>> has to return that input stream. The return value is just ignored if you don't combine operators.

Also, remember that input is modified by the values being read from it for p1, so we have to pass the modified stream to the second call so that p2 gets the next set of values from the stream instead of the same ones as p1.

Thank you very much Daved.

I might change it to istream later, but for this project there is really no points of doing it. The points will always be in a file. And there is no other use for them. If I am ever to use a point class in a personal project I will write a new one, this one has to many weird things in it (My teachers want me to do horrible things.. )

One last question:

I assume that input is passed as a reference due to speed? If the input is really big it will take time to copy it. But would not returning input defeat the purpose of the reference as the return will copy the value of input.

My writing is horrible today, hope it makes some sense.
Thanks :)

The return value of the function is also a reference.

Thanks for pointing that out, feel stupid now.

Thanks for all the help on this :)

Quote:

---

Originally Posted by h3ro

I assume that input is passed as a reference due to speed?

---

Streams are non-copyable. Why, I'll leave to other people.

If you copy a stream and start reading (or writing) from both copies, then it gets very confusing as to what should be getting read (or written) from (or to) where.

I am having some more problems with the >> operator.
I can input Points with >> as long as there is nothing else going on in the same line. Eg, this works:
input >> Point

but this does not
input >> string >> Point

Any ideas on what I am doing wrong? It might have something to do with inheritance maybe?

Code:

---

class Car
{
      public:
            ...
           
      protected:
                string name;
                Point pos; 
                ... 
};

class RaceCar : public Car
{
      friend std::ifstream &operator>>(std::ifstream &input, RaceCar &car);
     
      public:
            ...
 
      private:
              int size; 
              ... 
}

std::ifstream &operator>>(std::ifstream &input, RaceCar &car)
{
    input >> car.name >> car.size >> car.position;
    return input;           
}

---

Thanks

Well it is hard to tell, but the problem may go away if you turn your ifstreams (in the operator overload) into istreams as already suggested.

Quote:

---

Originally Posted by Daved

If you copy a stream and start reading (or writing) from both copies, then it gets very confusing as to what should be getting read (or written) from (or to) where.

---

I think the bigger problem is that an ifstream is a RAII object which closes the file when it goes out of scope. So if you were allowed to make copies, either one object would close the resource out from under the other, or the ifstream would have to somehow duplicate the file handle, which isn't necessarily possible on all platforms.

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.

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;   
}

---

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.

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;
};

---

Nice solution. Thanks a lot.

A consistent mistake in this thread: The second parameter of << should be const.

Quote:

---

Originally Posted by King Mir

A consistent mistake in this thread: The second parameter of << should be const.

---

Too bad everyone else is talking about operator >> not operator <<. So no mistake about that in this thread.