operator=() in base and derived class

M

MWimmer

Dear members of this group,

recently I came across a problem with repsect to operator=() and
inheritance. Consider the following code snippet:

------------------------------------------------------------
#include <iostream>

using namespace std;

class A
{
public:
A & operator=(const A &_a) {
cout << " in A" << endl;
}
};

class B : public A
{
public:
B & operator=(const A &_a) {
cout << " in B" << endl;
A::eek:perator=(_a);
}
};

main()
{
B b1, b2;
A a;

b1=b2;

cout << endl;

b1=a;
}
----------------------------------------

If you run this program (compiled using gcc 3.3 and 4.1), the output
you get is:

-------------------
in A

in B
in A
------------------

This means:
* for the assignment b1=b2, A::eek:perator=() is invoked
* for b1=a, B::eek:perator=() is invoked.

Now the solution to make the code behave as intended by me is to add
another function

B & operator=(const B&_B) {
cout << " in B" << endl;
A::eek:perator=(_b);
}

However, I don't understand the reasons for this behaviour and I'd
like to understand that. What are the rationales behind that behaviour?
 
U

Uday Bidkar

In b1=b2, since you haven't provided an operator =() in class B that
takes an object of B, you get a default one from compiler which would
do bitwise copy of B's members. Since you have provided an operator
=() in A, the compiler generated operator =() calls this one to copy
A's members. Hence you see a call to A::eek:perator=().

In b1=a, you have your own operator =() that takes object of class A
and hence this is the function that gets called.

-Uday Bidkar
 
W

wyg

Dear members of this group,

recently I came across a problem with repsect to operator=() and
inheritance. Consider the following code snippet:

------------------------------------------------------------
#include <iostream>

using namespace std;

class A
{
public:
A & operator=(const A &_a) {
cout << " in A" << endl;
}

};

class B : public A
{
public:
B & operator=(const A &_a) {
cout << " in B" << endl;
A::eek:perator=(_a);
}

};

main()
{
B b1, b2;
A a;

b1=b2;

cout << endl;

b1=a;}

----------------------------------------

If you run this program (compiled using gcc 3.3 and 4.1), the output
you get is:

-------------------
in A

in B
in A
------------------

This means:
* for the assignment b1=b2, A::eek:perator=() is invoked
* for b1=a, B::eek:perator=() is invoked.

Now the solution to make the code behave as intended by me is to add
another function

B & operator=(const B&_B) {
cout << " in B" << endl;
A::eek:perator=(_b);
}

However, I don't understand the reasons for this behaviour and I'd
like to understand that. What are the rationales behind that behaviour?

I copied some information from MSDN for you reference:
The assignment operator has some additional restrictions. It can be
overloaded only as a nonstatic member function, not as a friend
function. It is the only operator that cannot be inherited; a derived
class cannot use a base class's assignment operator.
 
M

MWimmer

In b1=b2, since you haven't provided an operator =() in class B that
takes an object of B, you get a default one from compiler which would
do bitwise copy of B's members. Since you have provided an operator
=() in A, the compiler generated operator =() calls this one to copy
A's members. Hence you see a call to A::eek:perator=().

In b1=a, you have your own operator =() that takes object of class A
and hence this is the function that gets called.

-Uday Bidkar

Ah, thanks a lot, that makes it clear!
 
L

Lance Diduck

Dear members of this group,

recently I came across a problem with repsect to operator=() and
inheritance. Consider the following code snippet:

------------------------------------------------------------
#include <iostream>

using namespace std;

class A
{
public:
A & operator=(const A &_a) {
cout << " in A" << endl;
}

};

class B : public A
{
public:
B & operator=(const A &_a) {
cout << " in B" << endl;
A::eek:perator=(_a);
}

};

main()
{
B b1, b2;
A a;

b1=b2;

cout << endl;

b1=a;}

----------------------------------------

If you run this program (compiled using gcc 3.3 and 4.1), the output
you get is:

-------------------
in A

in B
in A
------------------

This means:
* for the assignment b1=b2, A::eek:perator=() is invoked
* for b1=a, B::eek:perator=() is invoked.

Now the solution to make the code behave as intended by me is to add
another function

B & operator=(const B&_B) {
cout << " in B" << endl;
A::eek:perator=(_b);
}

However, I don't understand the reasons for this behaviour and I'd
like to understand that. What are the rationales behind that behaviour?

The compiler will implicily create an assignment operator, that just
calls assignment for member and base.
The only way not to get this is to define one yourself, that takes the
type as an argument. In this case, B&operator=(A const&); does not
turn off this implictly generated function.

The complier made up a function for you that looks like
B&operator=(B const&b){
A::eek:perator=(b);
}


Why does it do this? This is more to support some coding styles that
are essentially mixtures of C and C++. So in C we may have

struct A{
int g;
char buf[123];
};
struct B{
A a;//C version of inheritance
double d[543];
};
void foo(){
struct B b1,b2;
b1=b2;//C does a implicit memcpy underneath the hood

}
So you can see that the "implicit operator=" is a holdover from C.
when this is converted to C++, it may look like

struct A1{
int g;
std::string buf;
};
struct B1:A1{
std::vector<double> d;
};

void foo1(){
struct B1 b1,b2;
b1=b2;//C++ does a member by member operator= underneath the hood
//because string and vector will not survive a memcpy
}



Lance
 
A

anon

My comment will not change behavior of your classes, but aren't you
missing something here?
 
M

MWimmer

My comment will not change behavior of your classes, but aren't you
missing something here?

Yes I did miss the return *this - I forgot to add it in this made up
example.

Thanks guys, you've been very helpful, now i understand the problem :)
 
J

James Kanze

In b1=b2, since you haven't provided an operator =() in class B that
takes an object of B, you get a default one from compiler which would
do bitwise copy of B's members.

Not quite. The default operator= does a memberwise copy.
(Otherwise, he wouldn't have seen the message from the operator=
of the base class.) But you're right concerning the important
point here: unless you explicitly declare a "copy assignment"
operator=, the compiler implicitly generates one.

And just for completeness' sake, I'll add that a function
template operator= is never considered "copy assignment", and
will never prevent the compiler from generating its version.
Since you have provided an operator
=() in A, the compiler generated operator =() calls this one to copy
A's members. Hence you see a call to A::eek:perator=().

And if he hadn't provided it, of course, the assignment would
have been illegal.
 

Ask a Question

Want to reply to this thread or ask your own question?

You'll need to choose a username for the site, which only take a couple of moments. After that, you can post your question and our members will help you out.

Ask a Question

Members online

No members online now.

Forum statistics

Threads
473,743
Messages
2,569,478
Members
44,898
Latest member
BlairH7607

Latest Threads

Top