Move Semantics, Perfect Forwarding & Rvalue References

By the end of this lesson you'll be able to write generic code that forwards arguments without a single needless copy — choosing std::move vs std::forward correctly, reading reference-collapsing rules, and relying on copy elision and noexcept moves to make modern C++ fast.

1. Forwarding references vs rvalue references

You already know std::string&& is an rvalue reference: it binds only to temporaries. But the moment && is attached to a deduced template parameter — template <typename T> void f(T&& x) or auto&& — it becomes something different: a forwarding reference (also called a universal reference). A forwarding reference binds to both lvalues and rvalues, and remembers which one it caught. That memory is what makes perfect forwarding possible.

Read this worked example first. It is a perfect-forwarding factory: one template function that copies when handed a keepsake and moves when handed a disposable. Run it and watch which constructor fires for each call.

#include <iostream>
#include <string>
#include <utility>   // std::forward, std::move
using namespace std;

struct Widget {
    string name;
    // Two constructors so we can SEE which one runs:
    Widget(const string& n) : name(n) {            // copies from an lvalue
        cout << "  copy-ctor   ('" << name << "')\n";
    }
    Widget(string&& n) : name(std::move(n)) {       // steals from an rvalue
        cout << "  move-ctor   ('" << name << "')\n";
    }
};

// A FORWARDING reference: T
...

2. std::forward and perfect forwarding

A forwarding reference parameter has a name, so inside the function it is an lvalue — even if it caught an rvalue. If you pass it straight on, everything becomes a copy. std::forward<T>(x) fixes that: it re-casts x back to its original category. It returns an rvalue only if the caller passed an rvalue; otherwise it leaves an lvalue alone. That conditional cast is the entire difference from std::move, which casts unconditionally.

Your turn. The wrapper below catches its argument with a forwarding reference but passes it on incorrectly. Fill in the blank so the original category is preserved.

#include <iostream>
#include <string>
#include <utility>
using namespace std;

struct Logger {
    Logger(const string& s) { cout << "copied: "  << s << "\n"; }
    Logger(string&& s)      { cout << "moved:  "  << s << "\n"; }
};

// 🎯 YOUR TURN — finish this perfect-forwarding wrapper.
template <typename T>
Logger build(T&& value) {            // T&& is a FORWARDING reference here
    // We must preserve value's category. Inside this function 'value' is a
    // NAMED variable, so it is an lva
...

3. When to use std::move vs std::forward

The rule is short: use std::move on a plain rvalue reference (string&&), and std::forward<T> on a forwarding reference (deduced T&&). The trap is that a named rvalue reference is itself an lvalue, so if you forget the std::move, you silently copy. The exercise below has exactly that bug waiting — sink the string into the vector without copying it.

#include <iostream>
#include <string>
#include <vector>
#include <utility>
using namespace std;

// 🎯 YOUR TURN — sink the string into the vector WITHOUT copying it.
void store(vector<string>& out, string&& s) {
    // 's' is an rvalue REFERENCE, but because it now has a name it is an
    // lvalue inside this function. push_back will COPY unless you re-cast it.
    out.push_back(___);              // 👉 cast s back to an rvalue so it MOVES
    //                                  hint: std::mov
...

4. Reference collapsing — why forwarding works

You can't write a reference to a reference yourself, but template deduction can produce one internally. C++ then collapses it with one rule of thumb: if any & is involved, the result is &; only && && stays &&. So when you pass an lvalue to T&&, T deduces to U&, giving U& && which collapses to a plain lvalue reference. Pass an rvalue and T deduces to U, giving U&&. That asymmetry is precisely how a forwarding reference "remembers" what it caught.

This example proves the rule at runtime using is_lvalue_reference. The same inspect template deduces a different T depending on what you hand it.

#include <iostream>
#include <string>
#include <type_traits>
#include <utility>
using namespace std;

// A forwarding reference. What T deduces to drives reference collapsing:
//   pass an lvalue  -> T = U&   -> U& && collapses to U&   (lvalue ref)
//   pass an rvalue  -> T = U    -> U  && stays      U&&    (rvalue ref)
template <typename T>
void inspect(T&& x) {
    cout << "  is_lvalue_reference<T>: " << boolalpha
         << is_lvalue_reference<T>::value << "\n";
}

int main() {
    cout << "
...

5. Copy elision (RVO/NRVO) & noexcept moves

Copy elision is the compiler skipping a copy or move entirely by constructing the result straight into its destination. Since C++17, returning a temporary (a prvalue) is guaranteed to be elided — so return Heavy("x"); builds the object in the caller with zero moves. That's why return std::move(local); is an anti-pattern: it turns the value into something that can't be elided, blocking the optimisation it was meant to help.

Separately, marking your move constructor noexcept is what lets std::vector move its elements during reallocation instead of copying them. std::move_if_noexcept encodes the rule directly: it hands you an rvalue only when the move can't throw, otherwise an lvalue so a safe copy is made.

#include <iostream>
#include <vector>
#include <string>
#include <utility>   // std::move_if_noexcept
using namespace std;

struct Heavy {
    string label;
    Heavy(string l) : label(std::move(l)) { cout << "  ctor  " << label << "\n"; }
    Heavy(const Heavy& o) : label(o.label) { cout << "  COPY  " << label << "\n"; }
    // A noexcept move ctor lets std::vector move (not copy) on reallocation:
    Heavy(Heavy&& o) noexcept : label(std::move(o.label)) { cout << "  MOVE  " << label << "\n"; }
...

#include <iostream>
#include <string>
#include <utility>
using namespace std;

struct Resource {
    Resource(const string& s) { cout << "copy '" << s << "'\n"; }
    Resource(string&& s)      { cout << "move '" << s << "'\n"; }
};

int main() {
    // 🎯 MINI-CHALLENGE: a perfect-forwarding factory of your own
    // 1. Write:  template <typename T> Resource make(T&& v)
    //    that forwards v into a Resource using std::forward<T>(v).
    // 2. In main, call make() three times:
    //      - 
...