By using this site, you agree to our updated Privacy Policy and our Terms of Use. Manage your Cookies Settings.
449,079 Members | 891 Online
Bytes IT Community
+ Ask a Question
Need help? Post your question and get tips & solutions from a community of 449,079 IT Pros & Developers. It's quick & easy.

operator= for derived class

P: n/a
struct A{
A& operator=( const A& a ){ i = a.i; return *this; }

private:
int i;
};

struct B : public A{
B& operator=( const B& b ){ j = b.j; return *this; } // how to copy i?

private:
int j;
};

In the above code, what would be the standard way of coping A::i in
B::operator= ?
Jul 22 '05 #1
Share this Question
Share on Google+
3 Replies


P: n/a
MojoRison wrote:
struct A{
A& operator=( const A& a ){ i = a.i; return *this; }

private:
int i;
};

struct B : public A{
B& operator=( const B& b ){ j = b.j; return *this; } // how to copy i?

private:
int j;
};

In the above code, what would be the standard way of coping A::i in
B::operator= ?

For the classes in their presented form, there is no need for operator=.
But you probably already knew that.

The simple way is to call the A::operator= directly inside B::operator= :

B& operator=(const B& b) { A::operator=(b); j = b.j; return *this }

Victor
Jul 22 '05 #2

P: n/a
MojoRison wrote:
struct A{
A& operator=( const A& a ){ i = a.i; return *this; }

private:
int i;
};

struct B : public A{
B& operator=( const B& b ){ j = b.j; return *this; } // how to copy i?

private:
int j;
};

In the above code, what would be the standard way of coping A::i in
B::operator= ?


Firstly, for such classes you don't need to implement the copy
assignment operator explicitly. The one automatically provided by the
compiler will do exactly what you want.

If you still want to implement these operators manually, then the proper
way to do it would be calling the inherited copy assignment operator
('A::operator=') from B's implementation

B& operator=( const B& b ) {
A::operator=(b);
j = b.j;
return *this;
}

--
Best regards,
Andrey Tarasevich
Jul 22 '05 #3

P: n/a
MojoRison wrote:
struct A{
A& operator=( const A& a ){ i = a.i; return *this; }

private:
int i;
};

struct B : public A{
B& operator=( const B& b ){ j = b.j; return *this; } // how to copy i?

private:
int j;
};

In the above code, what would be the standard way of coping A::i in
B::operator= ?


I would make the operator= in the parent class
protected. This would prevent "slicing", where only the
parent portion is copied. See [1] below.

One method of implementing assignment operator in child
classes is:
Child&
Child ::
operator=(const Child& ch)
{
if (this != &child) /* guard against self assignment */
{
(Parent&)(*this) = (Parent&)(ch);
/* assignment of child members */
}
return *this;
}
The above fragment comes from Effective C++ or More Effective C++
by Scott Meyers.

[1] When parents allow public assignment, one can assign the
parent portion of child A to child B, using pointers to
the parent class.
struct Parent
{
Parent& operator=(const Parent& p);
};

struct Son : Parent
{
Son& operator=(const Son& s);
};

struct Daughter : Parent
{
Daughter& operator=(const Daughter& d);
};

/* ... */

Son bill;
Son jack;
Daughter amy;
Parent * p_male = &bill;
Parent * p_female = &amy;
Parent * p_brother = & jack;
*p_brother = *p_male; /* Are the child members copied? */
/* One _might_ think so... */
*p_male = *p_female; /* copies only parent portion */
/* Do you want this allowed? */

This has cost me many hours of debugging, so I've learned
to make assignment operators of base classes as protected.
to prevent the above scenario from occurring.

--
Thomas Matthews

C++ newsgroup welcome message:
http://www.slack.net/~shiva/welcome.txt
C++ Faq: http://www.parashift.com/c++-faq-lite
C Faq: http://www.eskimo.com/~scs/c-faq/top.html
alt.comp.lang.learn.c-c++ faq:
http://www.comeaucomputing.com/learn/faq/
Other sites:
http://www.josuttis.com -- C++ STL Library book
http://www.sgi.com/tech/stl -- Standard Template Library

Jul 22 '05 #4

This discussion thread is closed

Replies have been disabled for this discussion.