Should the Copy-and-Swap Idiom become the Copy-and-Move Idiom in C++11?

by

First of all, it is generally unnecessary to write a swap function in C++11 as long as your class is movable. The default swap will resort to moves:

void swap(T& left, T& right) {
    T tmp(std::move(left));
    left = std::move(right);
    right = std::move(tmp);
}

And that’s it, the elements are swapped.

Second, based on this, the Copy-And-Swap actually still holds:

T& T::operator=(T const& left) {
    using std::swap;
    T tmp(left);
    swap(*this, tmp);
    return *this;
}

// Let's not forget the move-assignment operator to power down the swap.
T& T::operator=(T&&) = default;

Will either copy and swap (which is a move) or move and swap (which is a move), and should always achieve close to the optimum performance. There might be a couple redundant assignments, but hopefully your compiler will take care of it.

EDIT: this only implements the copy-assignment operator; a separate move-assignment operator is also required, though it can be defaulted, otherwise a stack overflow will occur (move-assignment and swap calling each other indefinitely).

More Related Contents:

  1. When is overloading pass by reference (l-value and r-value) preferred to pass-by-value?
  2. Why do some people use swap for move assignments?
  3. How to enforce move semantics when a vector grows?
  4. When should std::move be used on a function return value? [duplicate]
  5. Reusing a moved container?
  6. Why no default move-assignment/move-constructor?
  7. Move assignment operator and `if (this != &rhs)`
  8. What are the rules for automatic generation of move operations?
  9. What does the standard library guarantee about self move assignment?
  10. Is a moved-from vector always empty?
  11. Why does std::move prevent RVO (return value optimization)?
  12. How to actually implement the rule of five?
  13. Does moving leave the object in a usable state?
  14. Why do we copy then move?
  15. Initializer-list-constructing a vector of noncopyable (but movable) objects
  16. Is a `=default` move constructor equivalent to a member-wise move constructor?
  17. Should I delete the move constructor and the move assignment of a smart pointer?
  18. Is an object guaranteed to be moved when it is returned?
  19. Why do you use std::move when you have && in C++11? [duplicate]
  20. Do built-in types have move semantics?
  21. Is there any case where a return of a RValue Reference (&&) is useful?
  22. When to make a type non-movable in C++11?
  23. Is std::array movable?
  24. C++11 virtual destructors and auto generation of move special functions
  25. When is explicit move needed for a return statement?
  26. Move out element of std priority_queue in C++11
  27. Why would I std::move an std::shared_ptr?
  28. Should all/most setter functions in C++11 be written as function templates accepting universal references?
  29. Move semantics == custom swap function obsolete?
  30. What is use of the ref-qualifier `const &&`?

Leave a Comment