Thread: Inheritance operator overloading

Hello,

Thank you in advance for your time and help.

I was hoping someone could clear some confusion up, over operator overloading and ineritance.

If i have overloaded the << and the >> operators, for example to output an object of type Square, and then i have an object of type circle that inherits from the Square class - how can i ouput an object of type circle without retyping the overloaded operators to accept an object of type circle.

e.g

Code:

friend istream& operator>>(istream&, Square&);
friend ostream& operator<<(ostream&, const Square);

and then i have a subclass (circle)...

Code:

friend istream& operator>>(istream&, Circle&);
friend ostream& operator<<(ostream&, const Circle);

I don't want to re-declare all of my overloaded operators.

How is this achieved?

I really appreiate some guidance in this area.

Thank you for your time, help and advice.

Best regards, global

If you have a scheme like

Code:

class Base {
public:
  
private:
      virtual void put(std::ostream& os);
};

you can then allow derived classes to override put, thereby making operator<<'s call to put dispatch to the appropriate derived class's function.

You would not need to alter the datatype returned. Keep your I/O handlers BASIC as possible! If you make it overly complex you may find it hard to override the function in one of the child classes.

Thank you for your help, it is, as always, greatly received.

So can i have what okinrus posted:

Code:

virtual void put(std::ostream& os);

Because i thought you had to have:

Code:

friend istream& operator>>(istream&, Square3&);
friend ostream& operator<<(ostream&, const Square3);

...and change it to Circle where appropriate, and write the whole function again.

I have 2 classes that both have 3 constructors and both need to be outputed to the screen - but surely i don't have to write everything all over again? Is there a way to make my methods, virtual methods?

If it's possible, i'll set about trying to do it - but i am not sure if it is yet.

Thank you for taking the time to read my post.

Best regards, gloabl

You mean like this?

Code:

class shape
{
  public:
   virtual void describe(){};
};
 
class square : public shape
{
  public:
   void describe() {cout << side << endl;}
   int side;
   friend ostream & operator<<(ostream & os, square rhs) { os << rhs.side;}
};
 
class circle : public shape
{
  public:
   void describe() {cout << radius << endl;}
   int radius;
   friend ostream & operator<<(ostream & os, circle rhs) { os << rhs.radius;}
};
 
int main()
{
  square s;
  s.side = 4;
 
  circle c;
  c.radius = 3;
 
  shape * shapes[2];
  shapes[0] = &s;
  shapes[1] = &c;
 
  //using polymorphism to output to screen
  for(int i = 0; i < 2; ++i)
	shapes[i]->describe();
 
  //overloading << operator to output to screen
  cout << s << endl;
  cout << c << endl;
 
}

More like this. Notice the virtual put method (as okinrus described) and how it does the work. Then notice how only one operator<< is required, because each derived class has its own put method that is automatically called because of polymorphism:

Code:

#include <iostream>

class shape
{
  public:
   virtual void put(std::ostream& os) const = 0;
   virtual ~shape() { }
};

std::ostream& operator<< (std::ostream& os, const shape& s)
{
    s.put(os);
    return os;
}

class square : public shape
{
  public:
   virtual void put(std::ostream& os) const {os << side << std::endl;}
   int side;
};
 
class circle : public shape
{
  public:
   virtual void put(std::ostream& os) const {os << radius << std::endl;}
   int radius;
};


int main()
{
  square s1;
  s1.side = 4;
 
  circle c1;
  c1.radius = 3;
 
  shape * shapes[2];
  shapes[0] = &s1;
  shapes[1] = &c1;
 
  //using polymorphism to output to screen
  for(int i = 0; i < 2; ++i)
    std::cout << *(shapes[i]);
 
  //overloading << operator to output to screen
  std::cout << s1;
  std::cout << c1;
}

Definitely cleaner. Thank you.