28

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

MyClass::MyClass(MyClass const &_copy) { *this = _copy; }
Improve this question
3
  • 10
    Use the copy-and-swap idiom. Commented Sep 6, 2010 at 15:28
  • Typically, the copy assignment operator will do some cleanup. If your class has a pointer to dynamically allocated memory, the first thing the copy-assignment operator should do is free that memory. This implementation of the copy constructor would give the copy assignment operator a dangling pointer, which you don't want to delete. Commented Nov 8, 2014 at 22:40
  • Even if you use smart pointers (in which case delete wouldn't an issue), you'd still be pointlessly default constructing and assigning all the member variables. Just use copy and swap. Commented Nov 8, 2014 at 22:43

8 Answers 8

Reset to default
36

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.

Improve this answer
Sign up to request clarification or add additional context in comments.

12 Comments

Actually, it doesn't matter if MyClass has a default constructor. Only if data members and base classes have one...
Ok, thanks. I was doing this to avoid code duplication in the implementation of the operator= and the copy constructor. With the copy-and-swap idiom the code is duplicated in the copy constructor and the swap method. Am I right?
@gregseth: not quite. The swap operation usually does "shallow" swap, for instance, by swapping just pointers (when appliable). The copy semantic is usually "deep" and thus quite different from the swap semantic. You don't have the code duplication which arises usually with copy ctor/operator= since operator= is implemented in terms of the copy ctor.
@NicHartley : Good one. First, write your move ctor, the most efficiently possible. If it is noexcept (that is, it never throws), then you can use std::swap instead of implementing swap yourself. If it is not noexcept, you'll need to think hard about exception safety (this is difficult). The assignment operator stays as is, taking by value and swapping (now with std::swap). If now you want move semantics but no copy semantics, then just have the assignment operator take a rvalue reference instead of by value, and swap as usual.
@KeyC0de you can of course, what I'm saying is that you can't specialize std::swap
|
13

It is more advisable to implement operator= in terms of an exception safe copy constructor. See Example 4. in this from Herb Sutter for an explanation of the technique and why it's a good idea.

http://www.gotw.ca/gotw/059.htm

Improve this answer

Comments

5

This implementation implies that the default constructors for all the data members (and base classes) are available and accessible from MyClass, because they will be called first, before making the assignment. Even in this case, having this extra call for the constructors might be expensive (depending on the content of the class).

I would still stick to separate implementation of the copy constructor through initialization list, even if it means writing more code.

Another thing: This implementation might have side effects (e.g. if you have dynamically allocated members).

Improve this answer

Comments

1

While the end result is the same, the members are first default initialized, only copied after that.

With 'expensive' members, you better copy-construct with an initializer list.

struct C { ExpensiveType member; C( const C& other ): member(other.member) {} }; };
Improve this answer

2 Comments

You can't initialize outside construction.
@GMan: darn. I meant to write the copy constructor, not the assignment. Sorry for that.
0

I would say this is not okay if MyClass allocates memory or is mutable.

Improve this answer

1 Comment

If it's not mutable, then it won't have an operator= -- that's a mutating function. Or do I not mean the same thing by mutable as you do?
0

yes.

personally, if your class doesn't have pointers though I'd not overload the equal operator or write the copy constructor and let the compiler do it for you; it will implement a shallow copy and you'll know for sure that all member data is copied, whereas if you overload the = op; and then add a data member and then forget to update the overload you'll have a problem.

Improve this answer

Comments

0

@Alexandre - I am not sure about passing by value in assignment operator. What is the advantage you will get by calling copy constructor there? Is this going to fasten the assignment operator?

P.S. I don't know how to write comments. Or may be I am not allowed to write comments.

Improve this answer

3 Comments

The usual reference is cpp-next.com/archive/2009/08/want-speed-pass-by-value. I'm still not convinced it's conclusions are always correct.
@Steve: For operator=, since you have to do the copy anyway, it cannot be worse.
@Alexandre C: yes it can. For example, if the function isn't inlined then it might result in more copies of the (call to) the copy constructor, bigger binaries, more cache misses, slower. The article mentions this, it isn't hiding anything, and I'm not convinced that it never matters whether the caller or the callee does a particular bit of work, on all compilers, ever.
0

It is technically OK, if you have a working assignment operator (copy operator).

However, you should prefer copy-and-swap because:

  • Exception safety is easier with copy-swap
  • Most logical separation of concerns:
    • The copy-ctor is about allocating the resources it needs (to copy the other stuff).
    • The swap function is (mostly) only about exchanging internal "handles" and doesn't need to do resource (de)allocation
    • The destructor is about resource deallocation
    • Copy-and-swap naturally combines these three function in the assignment/copy operator
Improve this answer

Comments

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.