Re: operator+ in derived classes

From:

"Jim Langston" <tazmaster@rocketmail.com>

Newsgroups:

comp.lang.c++

Date:

Thu, 29 Mar 2007 19:16:33 -0700

Message-ID:

<8q_Oh.12410$1W5.5602@newsfe02.lga>

"Jim Langston" <tazmaster@rocketmail.com> wrote in message
news:7h_Oh.12407$1W5.11275@newsfe02.lga...

This is something someone was asking in irc. I really don't need to do
this right now, but may have to in the future. The following code is in
error (marked).

#include <iostream>
#include <string>

class Base
{
public:
   Base( const int x = 0): x_( x ) {}
   Base operator+( const Base b ) { Base Temp( x_ ); Temp.x_ += b.x_;
return Temp; }
   int X() { return x_; }
   virtual ~Base() {}
private:
   int x_;
};

class Derived: public Base
{
public:
   Derived( const int x = 0, const int y = 0): Base( x ), y_( y ) {}
   int Y() { return y_; }
private:
   int y_;
};

int main()
{

   Base MyBase(10);
   std::cout << MyBase.X() << "\n";

   Base MyBase2 = MyBase + Base(5);
   std::cout << MyBase2.X() << "\n";

   Derived MyDerived( 10, 20 );
   std::cout << MyDerived.X() << " " << MyDerived.Y() << "\n";

My bad, the following line is the one in error, not the one below it. It's
the operator+ that's causing the problem, not the X() and Y();

    Derived MyDerived2 = MyDerived + Derived( 5, 10 );
   // error C2440: 'initializing' : cannot convert from 'Base' to 'Derived'
   // No constructor could take the source type, or constructor

   std::cout << MyDerived.X() << " " << MyDerived.Y() << "\n";
overload resolution was ambiguous

   std::string wait;
   std::getline( std::cin, wait );

}

I understand the error. I am tryign to operator+ on derived, but the only
operator + is on base.

How do people handle this?

What would be a nice solution, if possible, is to have a derived operator+
that calls the base operator+ for the addition of the x_'s, then add the
y_'s in derived operator+ and return derived. I couldn't come up with a
way to do this however, and think I would have to totally rewrite the
operator+ for derived. In this case it's trivial, but I could see a
complex class where it wouldn't be so trivial.

Any thoughts?