Move semantics — rvalue references (&&), std - move, std - forward: Foundations

Before you can read the parent note, you must own every symbol it throws at you. We build them one at a time — each one earns its place before the next appears.

0. The running example: a toy class `Str`

The parent note's derivations all use a tiny hand-written string class called Str. Every signature below (Str(const Str&), Str(Str&&), operator=) refers to this class, so we define it here before using its name anywhere else.

Definition The toy class

Str Str is a minimal string that owns a chunk of heap memory. It has exactly two data members:

char* data — a pointer (defined properly in section 2): it holds the address of the character buffer on the heap.
size_t len — an ordinary unsigned integer counting how many characters are stored (size_t = "the type used for sizes/counts").

class Str {
    char*  data;   // address of the heap buffer (the "guts")
    size_t len;    // how many characters
public:
    // constructors / destructor go here — built up in later sections
};

Whenever you see Str&, const Str&, or Str&& further down, picture this two-member object: a small stack box holding an address and a count. Stealing its guts means copying those two fields and blanking the source.

1. What "an object owning heap memory" even means

Figure — Move semantics — rvalue references (&&), std - move, std - forward

Look at the figure: the box on the left (str) sits on the stack. It holds an address (the pointer) and a length (how many characters are in use). The long buffer on the right sits on the heap. This split is the reason move semantics can be cheap: to hand off the whole thing, you only need to copy those few little numbers on the left, not the long buffer on the right.

2. The symbol `*` — a pointer, and what "owning" it means

3. The symbol `&` — "address of" AND "reference"

The parent note uses & in two totally different jobs. You must separate them.

4. `const T&` — a read-only alias that can outlive a temporary

Intuition Why binding a temporary to

const T& is safe — lifetime extension A temporary (rvalue) normally dies at the end of its statement. But there's a special rule: binding a temporary to a const lvalue reference extends the temporary's lifetime to match the reference. So in

const Str& s = makeStr();   // temporary would die...
// ...but s keeps it alive until s goes out of scope

the temporary is kept alive as long as s lives. That is the deeper reason it is safe — not merely "you can't write to it," but "the language guarantees it won't vanish under you." (Note: a plain T& cannot bind to a temporary at all, precisely because it could modify a value nobody else can see.)

5. lvalue vs rvalue — the single most important split

This is the concept the entire topic pivots on. Ignore the scary names; look at the picture.

Definition The finer value categories (glvalue, prvalue, xvalue)

C++ actually splits expressions into five categories, built from two independent yes/no questions: (i) does it have identity (a stable address you could name)? (ii) can it be moved from (plundered)? Two questions with two answers each give a little 2×2 grid, and the category names are just labels on that grid:

glvalue ("generalized lvalue") = answers yes to identity. Splits into:
- lvalue = identity yes, movable no (e.g. x, arr[i]). The named things.
- xvalue ("eXpiring value") = identity yes, movable yes (e.g. the result of std::move(x), or a function returning Str&&). It has a home but you've flagged it dying.
rvalue = answers yes to movable. Splits into:
- prvalue ("pure rvalue") = identity no, movable yes — a fresh temporary (e.g. 42, a + b, makeStr()).
- xvalue again. Why xvalue appears under both glvalue and rvalue: the two questions are independent, so "identity yes" and "movable yes" can both be true at once — and the xvalue is exactly that corner of the grid. Being "identity yes" makes it a glvalue; being "movable yes" makes it an rvalue. It is not a contradiction; it is simply the one category that answers yes to both questions. That is the whole point of std::move(x): it takes a named thing (identity yes) and adds the movable flag, producing the yes/yes corner. Why this matters for std::forward: a forwarding reference must be able to reproduce either a plain lvalue (identity yes, movable no) or an xvalue (identity yes, movable yes) depending on what the caller sent; that is precisely what std::forward does (section 8). For the parent note's day-to-day reasoning, "lvalue vs rvalue" is enough — this box is the precise version underneath it.

Worked example Same value, different category

Str a = makeStr();      // a is an LVALUE (named, has a home)
Str("hi");              // this expression is a PRVALUE (fresh temporary)
makeStr();              // PRVALUE (a fresh temporary result)
std::move(a);           // XVALUE (has a home, but marked movable)

6. `T&&` — the rvalue reference (and overload resolution)

The figure is the binding table as a picture: three doors (T&, const T&, T&&), two visitors (an lvalue and an rvalue). Notice T&& only opens for the temporary — that exclusivity is what lets overload resolution route temporaries into the fast move path. This same table drives Rule of Five.

7. `std::move`, the move constructor, and move assignment

8. Templates, type deduction & reference collapsing — where `std::forward` lives

9. `noexcept` — the promise that unlocks fast moves

Intuition Why that promise unlocks fast moves

When a std::vector runs out of room, it allocates a bigger buffer and must relocate every existing element into it. It has a choice: copy each element (slow but safe — the originals are untouched if something fails) or move each element (fast, but each move empties the original). Here's the danger: suppose the vector has moved 500 elements into the new buffer and the 501st move throws. The first 500 originals are now blanked, the new buffer is half-built — the vector cannot recover its old state. It would be left corrupt. To avoid ever facing this, the vector uses moves only if your move constructor is noexcept (a promise that the throw can't happen). If it might throw, the vector plays safe and copies instead. So noexcept is not decoration — it is the switch that lets std::vector reach for your fast move path at all. Forget it, and you silently lose move performance during every reallocation. Full rules: noexcept specifier.

10. `~ClassName()` and the double-delete danger

Prerequisite map

Equipment checklist

What are the two data members of the toy class Str, and what does each hold?

char* data — a pointer holding the address of the heap character buffer; size_t len — an unsigned integer holding the count of characters.

Where does the actual data of a Str/std::string live, and what does the stack object hold?

The characters live on the heap; the small stack object holds a pointer (address) and a length (a real std::string adds a capacity and often a small-string buffer).

What does RAII stand for and mean?

Resource Acquisition Is Initialization — an object grabs a resource in its constructor and releases it in its destructor, tying the resource's lifetime to the object's.

What is the difference between &x and int&?

&x is the address-of operator in an expression; int& is a reference type (an alias). Different jobs, same symbol.

Why is binding a temporary to const T& safe?

Because binding a temporary to a const lvalue reference extends the temporary's lifetime to match the reference — it won't vanish under you.

Which reference type binds only to rvalues?

T&& (rvalue reference).

Name the five value categories and the two questions defining them.

glvalue, prvalue, xvalue (and their parents lvalue, rvalue); defined by "has identity?" and "may be moved from?" — an xvalue answers yes to both, so it is both a glvalue and an rvalue.

What is overload resolution?

The compiler's step of choosing which same-named function to call based on the argument's value category (rvalue prefers T&& move; lvalue reaches const T& copy).

How does a move constructor differ from a copy constructor?

The copy ctor deep-duplicates the buffer; the move ctor steals the source's pointer and blanks the source. Move also has a partner: the move assignment operator for existing = temporary;.

Does std::move move anything at runtime?

No — it is static_cast<T&&>(x), a zero-cost relabel producing an xvalue so overload resolution picks the move path.

State all four reference-collapsing rules.

T& &→T&, T& &&→T&, T&& &→T&, T&& &&→T&& (only && && stays &&).

In f(x) vs f(makeInt()) for template<class T> void f(T&& a), what is T?

For the lvalue x, T = int& (collapses a to int&); for the prvalue, T = int (a is int&&).

Why does a noexcept move constructor unlock std::vector's fast path?

Because during reallocation a throwing move could leave the vector corrupt mid-relocation; std::vector only moves elements if the move is noexcept, otherwise it safely copies.