This document discusses C++ move semantics and how it improves performance over copying by allowing objects to be efficiently transferred instead of copied. It covers key aspects like rvalue references, which allow overloading functions to take advantage of moving from temporary objects or objects that will no longer be used. Move operations are implemented by swapping resource pointers/values from the source to the destination object and leaving the source in a valid but unspecified state. This improves scenarios like return value optimization and returning objects from functions by value.

1. Arindam Mukherjee
Pune C++ and Boost Meetup
C++11 MOVE SEMANTICS

2. Copying objects is bad
 Extra memory, extra CPU cycles to copy.
 May allocate heap memory, file descriptors,
etc.
 May fail.

3. Temporaries
 Objects not bound to a variable name
 Lifetime limited to the statement that
creates them
 Examples:
std::string s1, s2, s3;
std::string getName(); // prototype
std::string s4 = s1 + s2 + s3; // may copy
std::string s5 = getName(); // may copy

4. Return Value Optimization
 Copy elision: optimize copies, even when
they have side effects
 RVO: Elide copying of a returned temporary.
std::string getName() { return "foo"; }
std::string name = getName();
 Named RVO: Elide copying of a named
variable when returned from a function.
std::string getName() {
std::string s = "foo";
return s; }

5. RVO: no guarantees
 May not take effect in:
- Debug builds.
- Many but the most simple cases:
- Returning different named objects from
different return statements disables NRVO.
- NRVO does not mix with RVO.

6. Move, not copy
 Do a shallow copy to the destination
 Reset the source and stop using it
 Useful when:
- You anyway can’t use the source later:
std::string s = s1 + s2;
// s1 + s2 is a temporary
- You know you won’t use the source later.
- Copying is expensive and can fail.

7. l-value, r-value
 l-values: expressions with durable address.
May not be ok to move from.
int x = 5;foo(x);
char arr[16];arr[5] = 20;
 r-values: expressions without a durable
address – temporaries – always ok to move
from.
const string& s = string("Foo"), s2, s3;
setName(getName());
s3 = s + s2;

8. Overload on l- && r-values
 foo(string& s); // foo(s);
foo(const string& s); // foo(s1 + s2);
 Does not work because to move from, we
need a mutable reference.
 New class of mutable references – r-value
references:
foo(string& s); // foo(s);
foo(string&& s); // foo(s1 + 2);
// foo(getName())

9. Move: Overloading copy
 Copy suite:
string(const string& that);
string& operator=(const string& rhs);
 Move suite:
string(string&& that) noexcept;
string& operator=(string&& rhs) noexcept;

10. Implementing move
 X&& var only says it is ok to move from var.
 foo(X&& var) says foo may move from var.
 Implementer of foo still has to code the
actual move.
 Define a nothrow swap function that
exchanges pointers and primitive types or
delegates to other swaps. Swap source with
target.
 Make sure source is destructible after swap.

11. Return by value
 Return by value prefers move over copy.
std::string getName() {
std::string s1;
if (s1.size() > 0) {return s1;} //move
else {return string("default");} // rvo
}
std::string s1 = getName(); // rvo or move

12. Moving l-values
 You know you won’t use the source object
after this, but compiler doesn’t – so tell it.
foo(string& s); // 1
foo(string&& s); // 2
std::string s("Hello");
foo(s); // calls 1
foo(std::move(s)); // calls 2
 std::move casts the l-value expression to an r-value
expression.

13. Thank you!
 Q & A
 Thomas Becker’s C++ Rvalue references
explained: http://bit.ly/1ACRnAe