0

For a long time time I though that the correct way to implement a copy assignment (for a non trivial class) was to use the copy-swap idiom.

struct A{
   ... pointer to data
   A(A const& other){
       ... complicated stuff, allocation, loops, etc
   }
   void swap(A& other){... cheap stuff ...}
   A& operator=(A const& other){
      A tmp{other};
      swap(other);
      return *this;
   }
};

But then I heard this talk https://www.youtube.com/watch?v=vLinb2fgkHk by Howard Hinnant where he says that the copy-swap idiom is good to fulfill the strong-exception guarrantee but it is an overkill in general.

He mentions that here: https://youtu.be/vLinb2fgkHk?t=2616

So he suggests implement the copy assignment explicitly and have a separate function strong_assing(A& target, A const& source) containing the copy-swap.

What I don't understand is how A& operator=(A const& other) should be implemented then?

Does he suggest to have something like this?

   A& operator=(A const& other){
        ... don't allocate if not necessary
        ... loop element by element
        ... clean the bare minimum if there is a throw 
   }

Is this what std::vector implementations do then? That is, they do not use the copy-swap idiom at the end? Doesn't the standard vector requires the strong-exception guarantee?

alfC
  • 14,261
  • 4
  • 67
  • 118
  • You should define "correct". The pitfall of copy and swap is that you have 3 objects peak instead of two objects peak while you don't necessary want to preserve an old value in case of assignment failure. – user7860670 Jul 22 '18 at 08:37
  • `std::vector` can copy a buffer internally, then swap it. So it does not need copy and swap at the level of the assignment operator parameter. – juanchopanza Jul 22 '18 at 09:11
  • 1
    There is no "one right way" to implement a copy assignment operator. And the main point of the talk you reference is that copy/swap is _not_ the "one right way" to implement a copy assignment operator, especially if you have vector and/or string data members (either directly or indirectly). – Howard Hinnant Jul 22 '18 at 16:11
  • 1
    [Here you can view for yourself an actual, industrial-grade vector copy assignment operator](https://github.com/llvm-mirror/libcxx/blob/master/include/vector#L1384-L1395). – Howard Hinnant Jul 22 '18 at 16:12
  • Thank you @HowardHinnant. I though that copy-swap was used because it was superior to `A::operator=(const A& __x){if (this != &__x){...} ...};` (used in your linked code) but apparently it is still the correct way to start when only the basic-exception guarantee is necessary. no? – alfC Jul 22 '18 at 18:21
  • 2
    @alfC: The very best `operator=` start (and end) with `= default`. It is difficult for me to give a general recipe for this function. It should give the lhs the state of the rhs, keep the rhs state unchanged, usually create two distinct (unlinked) values, not leak any memory, have at least basic exception safety, and be as high performance as possible. A decent first cut at estimating performance is to count the number of allocations and deallocations. – Howard Hinnant Jul 22 '18 at 22:04
  • @HowardHinnant If I understand correctly `std::vector` doesn't have the strong exception guarantee. And that is not bad thing since the strong exception guarantee is not required. I think I also understand that copy-swap (for a vector-like) will always call allocate for the third object, while obviously there are (runtime) cases in which allocations would not be necessary to copy a container. – alfC Jul 23 '18 at 07:46
  • @VTT, from what I learned here, apparently there are two "correct" ways, strong-exception guarantee (SEG) and basic-exception guarantee (BEG). The second can be faster in many cases. I wonder how to decide whether copy assignment should be SEG or BEG. I don't usually see this documented (e.g. https://en.cppreference.com/w/cpp/container/vector/operator%3D) – alfC Jul 23 '18 at 07:50
  • 1
    @alfC: If the spec says nothing about it, you can assume basic. When the spec says something different, it will look like the exception-clause for [`vector::push_back`](https://en.cppreference.com/w/cpp/container/vector/push_back). The design philosophy that the committee used for deciding when to provide the strong guarantee was "when it does not add a performance penalty to do so." – Howard Hinnant Jul 23 '18 at 13:17

0 Answers0