question about copy constructor and assignment operator

Hi all,

In which cases does the compiler forces us to have a copy constructor and an assignment operator? I mean, when we have to define both explicitly.

Thanks in advance

Never? The whole point of writing either of those things is that you decide if you need them to do something different than what the compiler gives you, because there are different kinds of copies.

The compiler assumes that it can just assign all the members like this when you use assignment:

foo = rhs.foo;
bar = rhs.bar;

and so on. Memory management is the most common reason this will not be appropriate and then you will need to write your own assignment operator. For instance, an object may have raw pointers as members that should be handled. They teach that stuff in class.

Writing a copy constructor is usually a prerequisite for implementing assignment which looks like this:

Code:

object & operator = (object & lhs , const object & rhs)
{
   return object(lhs).swap(rhs);
}

where swap is a member function that swaps two objects. It may be the easiest way but it is not the only way, of course.

Most of what you said I already know, but I was asked that question and couldn't really find a case and still can't. Maybe it was a trick question.

By the way, whiteflags' example is a little flawed in that, at least with respect to the current version of the C++ standard, an overloaded copy assignment operator must be a non-static member function. Furthermore, swap functions typically have a void return type. As such, you are more likely to see this:

Code:

object& object::operator=(object rhs)
{
    swap(rhs);
    return *this;
}

or:

Code:

object& object::operator=(const object& rhs)
{
    object temp(rhs);
    swap(temp);
    return *this;
}

A check for this != &rhs might be performed.

Well, thanks for the replies whiteflags and laserlight. Regarding the question maybe I didn't understand it correctly, because I can't find any answer/hints to it.

Originally Posted by sugarfree

Regarding the question maybe I didn't understand it correctly, because I can't find any answer/hints to it.

You might find these interesting:

Originally Posted by C++03 Section 12.8 Paragraph 7

An implicitly-declared copy constructor is implicitly defined if it is used to initialize an object of its class type from a copy of an object of its class type or of a class type derived from its class type. [Note: the copy constructor is implicitly defined even if the implementation elided its use. ] A program is ill-formed if the class for which a copy constructor is implicitly defined has:

• a nonstatic data member of class type (or array thereof) with an inaccessible or ambiguous copy constructor, or
• a base class with an inaccessible or ambiguous copy constructor.

Originally Posted by C++03 Section 12.8 Paragraph 12

An implicitly-declared copy assignment operator is implicitly defined when an object of its class type is assigned a value of its class type or a value of a class type derived from its class type. A program is ill-formed if the class for which a copy assignment operator is implicitly defined has:

• a nonstatic data member of const type, or
• a nonstatic data member of reference type, or
• a nonstatic data member of class type (or array thereof) with an inaccessible copy assignment operator, or
• a base class with an inaccessible copy assignment operator.

This basicaly says when you should write them:
http://en.wikipedia.org/wiki/Rule_of...2B_programming)
rule of three@Everything2.com

By the way, whiteflags' example [...] must be a non-static member function.

You're both crazy. The "rhs" should not be constant.

Soma

Originally Posted by phantomotap

The "rhs" should not be constant.

Heheh, oh yeah, otherwise we'll be trying to swap with something that is const. Fixed.