How to actually implement the rule of five?

by

You’ve missed a significant optimization in your copy assignment operator. And subsequently the situation has gotten confused.

  AnObject& operator = ( const AnObject& rh )
  {
    if (this != &rh)
    {
      if (n != rh.n)
      {
         delete [] a;
         n = 0;
         a = new int [ rh.n ];
         n = rh.n;
      }
      std::copy(rh.a, rh.a+n, a);
    }
    return *this;
  }

Unless you really never think you’ll be assigning AnObjects of the same size, this is much better. Never throw away resources if you can recycle them.

Some might complain that the AnObject‘s copy assignment operator now has only basic exception safety instead of strong exception safety. However consider this:

Your clients can always take a fast
assignment operator and give it strong
exception safety. But they can’t take
a slow assignment operator and make it
faster.

template <class T>
T&
strong_assign(T& x, T y)
{
    swap(x, y);
    return x;
}

Your move constructor is fine, but your move assignment operator has a memory leak. It should be:

  AnObject& operator = ( AnObject&& rh )
  {
    delete [] a;
    n = rh.n;
    a = rh.a;
    rh.n = 0;
    rh.a = nullptr;
    return *this;
  }

…

Data a = MakeData();
Data c = 5 * a + ( 1 + MakeMoreData() ) / 3;

q2: Using a combination of copy elision / RVO / move semantics the
compiler should be able to this this
with a minimum of copying, no?

You may need to overload your operators to take advantage of resources in rvalues:

Data operator+(Data&& x, const Data& y)
{
   // recycle resources in x!
   x += y;
   return std::move(x);
}

Ultimately resources ought to be created exactly once for each Data you care about. There should be no needless new/delete just for the purpose of moving things around.

More Related Contents:

  1. C++11 rvalues and move semantics confusion (return statement)
  2. Why is `std::move` named `std::move`?
  3. Is the pass-by-value-and-then-move construct a bad idiom?
  4. Is it possible to std::move objects out of functions? (C++11)
  5. Why do some people use swap for move assignments?
  6. Can I typically/always use std::forward instead of std::move?
  7. Is there any case where a return of a RValue Reference (&&) is useful?
  8. What is use of the ref-qualifier `const &&`?
  9. push_back vs emplace_back
  10. What does T&& (double ampersand) mean in C++11?
  11. What is std::move(), and when should it be used?
  12. Can I list-initialize a vector of move-only type?
  13. How do I use a custom deleter with a std::unique_ptr member?
  14. What constitutes a valid state for a “moved from” object in C++11?
  15. Syntax for universal references
  16. C++11 move constructor not called, default constructor preferred
  17. Move-only version of std::function
  18. Why user-defined move-constructor disables the implicit copy-constructor?
  19. What’s a use case for overloading member functions on reference qualifiers?
  20. non-class rvalues always have cv-unqualified types
  21. Non-copyable elements in vector
  22. Can compiler generate std::move for a last use of lvalue automatically?
  23. On how to recognize Rvalue or Lvalue reference and if-it-has-a-name rule
  24. Understanding rvalue references
  25. Operator overload which permits capturing with rvalue but not assigning to
  26. Should the Copy-and-Swap Idiom become the Copy-and-Move Idiom 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. Overloading on R-value references and code duplication
  30. Move semantics == custom swap function obsolete?

Leave a Comment