Nikos Athanasiou gave a good answer but I wanted to add this tool that I think is very useful. Here is a screenshot of Howard Hinnant’s presentation “Everything You Ever Wanted To Know About Move Semantics (and then some)” from ACCU 2014 conference which I think is a very good reminder of the rules of … Read more
Yes, if you move the shared pointer into the function, then: the original sourcePtr will become null, and the reference count does not get modified. If you know that you will no longer need the value of sourcePtr after the function call, moving it into the function is a slight optimisation, as it saves an … Read more
In the second version, there is an advantage. Calling emplace_back will call the move constructor of std::string when std::move is used, which could save on a copy (so long as that string isn’t stored in a SSO buffer). Note that this is essentially the same as push_back in this case. std::move in the first version … Read more
As you can see, ByVal produces 1 extra move compared to pair of reference overloads. So the question is: is it worth it? When would you create two overloads instead of one simple pass by value function? +1 Most people who ask this question don’t bother to do the analysis. So you get my upvote … Read more
Moving from an object just means that the moved-from object might donate its guts to live on in another live object shortly before it is [probably] going to die. Note, however, that just because an object donated its guts that the object isn’t dead! In fact, it may be revived by another donating object and … Read more
If the code looks like it should be optimized, but is not getting optimized I would submit bug here http://connect.microsoft.com/VisualStudio or raise a support case with Microsoft. This article, although it is for VC++2005 (I couldn’t find a current version of document) does explain some scenarios where it won’t work. http://msdn.microsoft.com/en-us/library/ms364057(v=vs.80).aspx#nrvo_cpp05_topic3 If we want to … Read more
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, … Read more
The compiler may NRVO into a temp space, or move construct into a temp space. From there it will move assign x. Update: Any time you’re tempted to optimize with rvalue references, and you’re not positive of the results, create yourself an example class that keeps track of its state: constructed default constructed moved from … Read more
Expensive-to-move types are rare in modern C++ usage. If you are concerned about the cost of the move, write both overloads: void set_a(const A& a) { _a = a; } void set_a(A&& a) { _a = std::move(a); } or a perfect-forwarding setter: template <typename T> void set_a(T&& a) { _a = std::forward<T>(a); } that will … Read more
From section 17.3.26 of the spec “valid but unspecified state”: an object state that is not specified except that the object’s invariants are met and operations on the object behave as specified for its type [ Example: If an object x of type std::vector<int> is in a valid but unspecified state, x.empty() can be called … Read more