Assignment Operator Problem on Based and Derived Class

[yccheok]

Hello all, I am confused on the correct assignment operator that
should be implemented on the derived class. I refer to the document
found at :-

http://www.icu-project.org/docs/pape..._operator.html

which the author recommence not using "virtual" for assignment
operator. Hence, I provide the following implementation.

#include <iostream>

using namespace std;

class B {
public:
B(int i) : b(i) {}

B& operator=(const B& me) {
if(&me == this) return *this;

b = me.b;

cout<< "b assignment"<< endl; return *this;
}

virtual void fun() { cout<< "b: " << b << endl; }

private:
int b;

};

class D: public B {
public:
D(int i) : B(i), d(i) {}

D& operator=(const D& me) {
if(&me == this) return *this;

d = me.d;

B::operator =(me); cout<< "d assignment"<< endl; return *this;
}

virtual void fun() { B::fun(); cout<< "d: " << d << endl; }

private:
int d;
};

int main()
{
cout<< "main"<< endl;

B* b0 = new D(100);
B* b1 = new D(200);

(*b0).fun(); // "b: 100"
// "d: 100"
// printed. Correct behavior.

*b0 = *b1; // "b assignment" printed. is this the correct
expectation?
// shall we expected "b assignment", followed by "d assignment"
// to be printed? If yes, what shall be the correct
implementation?

(*b0).fun(); // "b: 200"
// "d: 100"
// printed. Now the result is "half-baked". The based class are
// being assigned properly. However, the child class is not

delete b0;
delete b1;
}

It seems that for me, the assignment operator implementation for
derived class is not correct (At least it shall not produce "half-
baked result) May I know what shall the correct implementation for
that? Any suggestion are welcomed.

Thanks!

cheok

[Victor Bazarov]

yccheok wrote:

Hello all, I am confused on the correct assignment operator that
should be implemented on the derived class. I refer to the document
found at :-

http://www.icu-project.org/docs/pape..._operator.html

which the author recommence not using "virtual" for assignment
operator. Hence, I provide the following implementation.

#include <iostream>

using namespace std;

class B {
public:
B(int i) : b(i) {}

B& operator=(const B& me) {
if(&me == this) return *this;

b = me.b;

cout<< "b assignment"<< endl; return *this;
}

virtual void fun() { cout<< "b: " << b << endl; }

private:
int b;

};

class D: public B {
public:
D(int i) : B(i), d(i) {}

D& operator=(const D& me) {
if(&me == this) return *this;

d = me.d;

B::operator =(me); cout<< "d assignment"<< endl; return *this;
}

virtual void fun() { B::fun(); cout<< "d: " << d << endl; }

private:
int d;
};

int main()
{
cout<< "main"<< endl;

B* b0 = new D(100);
B* b1 = new D(200);

(*b0).fun(); // "b: 100"
// "d: 100"
// printed. Correct behavior.

*b0 = *b1; // "b assignment" printed. is this the correct
expectation?
// shall we expected "b assignment", followed by "d assignment"
// to be printed? If yes, what shall be the correct
implementation?

(*b0).fun(); // "b: 200"
// "d: 100"
// printed. Now the result is "half-baked". The based class are
// being assigned properly. However, the child class is not

delete b0;
delete b1;
}

It seems that for me, the assignment operator implementation for
derived class is not correct (At least it shall not produce "half-
baked result) May I know what shall the correct implementation for
that? Any suggestion are welcomed.

class B { ...

virtual B& operator=(B const& b)
{ /* same as you have it */ }
};

class D : public B {
...
virtual D& operator =(B const& b) {
// check if 'b' is actually a D
if (D const* pD = dynamic_cast<D const*>(&b)) {
return *this = *pD;
}
else { // something else, assign only base part???
return B::operator=(b);
}
}

virtual D& operator =(D const& d) {
// whatever
}
}

HTH

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