Implementing the copy constructor in terms of operator=

Question

If the operator= is properly defined, is it OK to use the following as copy constructor?

MyClass::MyClass(MyClass const &_copy) {     *this = _copy; } 

Answer 1

If all members of MyClass have a default constructor, yes.

Note that usually it is the other way around:

class MyClass { public:     MyClass(MyClass const&);     // Implemented     void swap(MyClass&) throw(); // Implemented     MyClass& operator=(MyClass rhs) { rhs.swap(*this); return *this; } }; 

We pass by value in operator= so that the copy constructor gets called. Note that everything is exception safe, since swap is guaranteed not to throw (you have to ensure this in your implementation).

EDIT, as requested, about the call-by-value stuff: The operator= could be written as

MyClass& MyClass::operator=(MyClass const& rhs) {     MyClass tmp(rhs);     tmp.swap(*this);     return *this; } 

C++ students are usually told to pass class instances by reference because the copy constructor gets called if they are passed by value. In our case, we have to copy rhs anyway, so passing by value is fine.

Thus, the operator= (first version, call by value) reads:

• Make a copy of rhs (via the copy constructor, automatically called)
• Swap its contents with *this
• Return *this and let rhs (which contains the old value) be destroyed at method exit.

Now, we have an extra bonus with this call-by-value. If the object being passed to operator= (or any function which gets its arguments by value) is a temporary object, the compiler can (and usually does) make no copy at all. This is called copy elision.

Therefore, if rhs is temporary, no copy is made. We are left with:

• Swap this and rhs contents
• Destroy rhs

So passing by value is in this case more efficient than passing by reference.