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 … Read more
It’s my fault. (half-kidding, half-not). When I first showed example implementations of move assignment operators, I just used swap. Then some smart guy (I can’t remember who) pointed out to me that the side effects of destructing the lhs prior to the assignment might be important (such as the unlock() in your example). So I … Read more
The copy constructor exists to make copies. In theory when you write a line like: CLASS c(foo()); The compiler would have to call the copy constructor to copy the return of foo() into c. Copy elision is a technique to skip calling the copy constructor so as not to pay for the overhead. For example, … Read more
For types whose copy assignment operator can recycle resources, swapping with a copy is almost never the best way to implement the copy assignment operator. For example look at std::vector: This class manages a dynamically sized buffer and maintains both a capacity (maximum length the buffer can hold), and a size (the current length). If … Read more
Overview Why do we need the copy-and-swap idiom? Any class that manages a resource (a wrapper, like a smart pointer) needs to implement The Big Three. While the goals and implementation of the copy-constructor and destructor are straightforward, the copy-assignment operator is arguably the most nuanced and difficult. How should it be done? What pitfalls … Read more