operator+ in derived classes

[Jim Langston]

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

Derived MyDerived2 = MyDerived + Derived( 5, 10 );
// Following line gives compilation error
std::cout << MyDerived.X() << " " << MyDerived.Y() << "\n";
// error C2440: 'initializing' : cannot convert from 'Base' to 'Derived'
// No constructor could take the source type, or constructor
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?

[Jim Langston]

"Jim Langston" <ta*******@rocketmail.comwrote in message
news:7h*******************@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?

[Victor Bazarov]

Jim Langston wrote:

"Jim Langston" <ta*******@rocketmail.comwrote in message
news:7h*******************@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 ) {}

Add here

Derived(const Base& b) : Base(b), y_(0) {}

> 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?

Add the constructor from Base.

>>[..]

Any thoughts?

--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask

[Jim Langston]

"Victor Bazarov" <v.********@comAcast.netwrote in message
news:Pf******************************@comcast.com. ..

Jim Langston wrote:

>"Jim Langston" <ta*******@rocketmail.comwrote in message
news:7h*******************@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 ) {}

Add here

Derived(const Base& b) : Base(b), y_(0) {}

>> 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?

Add the constructor from Base.

That semi works. I.E. After fixing typos (actually displaying MyDerived2
values) my output is:
10
15
10 20
15 0

When I would want output of:
10
15
10 20
15 30

So I'm thinking I'm going to need to add y_ to y_ in derived. I tried to
add an operator+ to Derived with no success in getting what I want.

Derived operator+( const Derived& d ) { Derived Temp( X(), y_ ); Temp.y_ +=
d.y_; return Temp; }

Output is now
10
15
10 20
10 30

So it seems I can either add the base variables, or the derived variables,
but not both. I tried this but can't get it to compile

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 ) {}
Derived operator+( const Derived& d )
{
// Error on following line
Base TempBase = Base( this->X() ) + Base( d.X() );
// error C2662: 'Base::X' : cannot convert 'this' pointer from
'const Derived' to 'Base &'
Derived Temp( TempBase.X(), y_ );
Temp.y_ += d.y_;
return Temp;
}
int Y() { return y_; }
private:
int y_;
};

I can't figure out why I'm getting that error. It seems I can't get d.X().
I tried int TempInt = d.X() with the same error. I know outside the class
in mainline I can get a derived.X(); why cant' I in the operator+?

[c++ seeker]

On 3ÔÂ30ÈÕ, ÉÏÎç10ʱ06·Ö, "Jim Langston" <[e-mail]:

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

Derived MyDerived2 = MyDerived + Derived( 5, 10 );
// Following line gives compilation error
std::cout << MyDerived.X() << " " << MyDerived.Y() << "\n";
// error C2440: 'initializing' : cannot convert from 'Base' to 'Derived'
// No constructor could take the source type, or constructor
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?

Derived& operator+(const Derived &d){
this->Base::operator+(d);
this->y_ += d.y_;
return *this;
}

[Jim Langston]

"Jim Langston" <ta*******@rocketmail.comwrote in message
news:If*****************@newsfe06.lga...

"Victor Bazarov" <v.********@comAcast.netwrote in message
news:Pf******************************@comcast.com. ..

>Jim Langston wrote:

>>"Jim Langston" <ta*******@rocketmail.comwrote in message
news:7h*******************@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 ) {}

Add here

Derived(const Base& b) : Base(b), y_(0) {}

>>> 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?

Add the constructor from Base.

That semi works. I.E. After fixing typos (actually displaying MyDerived2
values) my output is:
10
15
10 20
15 0

When I would want output of:
10
15
10 20
15 30

<Snipped trial and error til I got it right>

This is what I wound up donig. Is this the way you would necessarily do it?

#include <iostream>
#include <string>

class Base
{
public:
Base( const int x = 0): x_( x ) {}
Base operator+( const Base b ) const { Base Temp( x_ ); Temp.x_ += b.x_;
return Temp; }
int X() const { 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 ) {}
Derived operator+( const Derived& d ) const
{
Base TempBase = Base( this->X() ) + Base( d.X() );
Derived Temp( TempBase.X(), y_ );
Temp.y_ += d.y_;
return Temp;
}
int Y() const { 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";

Derived MyDerived2 = MyDerived + Derived( 5, 10 );
std::cout << MyDerived2.X() << " " << MyDerived2.Y() << "\n";

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

}

Output is my wanted:
10
15
10 20
15 30

[Jim Langston]

"c++ seeker" <te*****@gmail.comwrote in message
news:11**********************@p15g2000hsd.googlegr oups.com...
On 3ÔÂ30ÈÕ, ÉÏÎç10ʱ06·Ö, "Jim Langston" <[e-mail]:

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

Derived MyDerived2 = MyDerived + Derived( 5, 10 );
// Following line gives compilation error
std::cout << MyDerived.X() << " " << MyDerived.Y() << "\n";
// error C2440: 'initializing' : cannot convert from 'Base' to
'Derived'
// No constructor could take the source type, or constructor
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?

Derived& operator+(const Derived &d){
this->Base::operator+(d);
this->y_ += d.y_;
return *this;
}

Output of that is:
10
15
10 20
10 30

Instead of
10
15
10 20
15 30

Also, it changes this, but += is not what I wanted.

[Victor Bazarov]

Jim Langston wrote:

"Jim Langston" <ta*******@rocketmail.comwrote in message
news:If*****************@newsfe06.lga...

>"Victor Bazarov" <v.********@comAcast.netwrote in message
news:Pf******************************@comcast.com ...

>>Jim Langston wrote:
"Jim Langston" <ta*******@rocketmail.comwrote in message
news:7h*******************@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 )
{}

Add here

Derived(const Base& b) : Base(b), y_(0) {}

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?

Add the constructor from Base.

That semi works. I.E. After fixing typos (actually displaying
MyDerived2 values) my output is:
10
15
10 20
15 0

When I would want output of:
10
15
10 20
15 30

<Snipped trial and error til I got it right>

This is what I wound up donig. Is this the way you would necessarily
do it?
#include <iostream>
#include <string>

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

It should really be shorter:

Base operator+(const Base& b) const { return Base(b.x_ + x_); }

int X() const { 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 ) {}
Derived operator+( const Derived& d ) const
{
Base TempBase = Base( this->X() ) + Base( d.X() );
Derived Temp( TempBase.X(), y_ );
Temp.y_ += d.y_;
return Temp;
}

Yep, something like that. You don't really need to construct new Base
objects from X(). You could just cast '*this' and 'd' to Base&:

Derived operator+( const Derived& d ) const
{
Base TempBase(Base(*this) + Base(d)); // fall back on Base::op+
return Derived( TempBase.X(), y_ + d_.y );

}

int Y() const { 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";

Derived MyDerived2 = MyDerived + Derived( 5, 10 );
std::cout << MyDerived2.X() << " " << MyDerived2.Y() << "\n";

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

}

Output is my wanted:
10
15
10 20
15 30

See above. I don't know the output -- no time to try, and too lazy
to just look and figure it out. However, it might not be what you
want. Generally, you do want to fall back on Base::operator+ as
much as possible instead of adding 'x_' values yourself. For that
you might want to make operator+ virtual...

V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask