Move Semantics in C++

By the end of this lesson you'll know exactly why std::move makes code faster, how to write a move constructor and move assignment that steal resources instead of copying them, and how the standard library uses moves under the hood — so your own types stop paying for needless copies.

1. lvalues, rvalues, and T&&

Every expression in C++ is either an lvalue or an rvalue. An lvalue has a name and a lasting address — like a variable x; you can take its address with &x. An rvalue is a temporary with no lasting identity — like the literal 42, or the result of x + 1; it vanishes at the end of the line. This matters because you can safely steal from an rvalue: nothing else will ever look at it again.

A plain reference T& binds to lvalues. The new tool is the rvalue reference, written T&& (two ampersands), which binds to rvalues — to temporaries. That double-ampersand parameter is how a function says "I will only run for throwaway values, so I'm allowed to gut them."

int x = 10;        // x is an lvalue (has a name & address)
int& lref = x;     // T&  binds to the lvalue x       -> OK
int&& rref = 10;   // T&& binds to the rvalue 10      -> OK
// int&& bad = x;  // ERROR: x is an lvalue, not a temporary

2. std::move and the Move Constructor

std::move sounds like it moves data, but it does nothing at runtime. It is just a cast that turns an lvalue into an rvalue reference, so the compiler picks the move constructor (T(T&&)) instead of the copy constructor (T(const T&)). The move constructor is where the real work happens: it steals the source's internal buffer — usually a single pointer swap — instead of duplicating millions of elements. The source is left empty but valid.

Read this worked example and run it. The class prints whether a copy or a move ran, so you can see exactly which constructor the compiler chose.

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

// A class that owns a "big" buffer so copies are visibly expensive.
class Buffer {
    string label;
    vector<int> data;   // imagine this holds millions of ints
public:
    // Normal constructor
    Buffer(string l, int n) : label(l), data(n, 0) {
        cout << label << ": constructed (" << n << " ints)" << endl;
    }

    // Copy constructor — runs when you COPY. It duplicates the whole buffer.
    Buffer(const
...

Your turn. The class below has a working copy constructor; the move constructor is missing two pieces. Fill in the ___ blanks so it steals the buffer and promises not to throw.

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

class Box {
    vector<int> data;
public:
    Box(int n) : data(n, 1) {}

    // Copy constructor — already written for you.
    Box(const Box& other) : data(other.data) {
        cout << "COPIED" << endl;
    }

    // 🎯 YOUR TURN — finish the MOVE constructor.
    // Steal 'other.data' instead of copying it, and don't throw.
    Box(Box&& other) ___ : data(___) {   // 👉 add 'noexcept', then move(other.data)
       
...

Now practise calling std::move yourself. Moving a std::string hands its character buffer to the destination and leaves the original empty — no characters are copied.

#include <iostream>
#include <string>
#include <utility>   // std::move lives here
using namespace std;

int main() {
    // 🎯 YOUR TURN — move a string instead of copying it.
    string from = "a very long sentence pretending to be huge";
    string to;

    // 1) Move 'from' into 'to' (steal its characters, don't copy them)
    to = ___;                   // 👉 move(from)

    cout << "to   = \"" << to << "\"" << endl;
    cout << "from = \"" << from << "\" (moved-from: empty but valid)" << e
...

string a = "Hello, this is a long string";
string b = move(a);   // b steals a's buffer (pointer swap)
// b == "Hello, this is a long string"
// a == ""  (valid but empty — its buffer now belongs to b)

3. Move Assignment and the Rule of Five

A move constructor builds a new object from a temporary. Move assignment (operator=(T&&)) instead replaces an existing object: it must first free whatever it already holds, then steal the source's resource. The Rule of Five says that once you manually manage a resource and write any one of these five special members, you should write all five so they agree on ownership:

class Widget {
    int* data;
public:
    Widget(int n) : data(new int[n]) {}          // 1. constructor

    ~Widget() { delete[] data; }                 // 2. destructor

    Widget(const Widget& o);                      // 3. copy constructor
    Widget& operator=(const Widget& o);           // 4. copy assignment

    Widget(Widget&& o) noexcept                   // 5a. move constructor
        : data(o.data) { o.data = nullptr; }
    Widget& operator=(Widget&& o) noexcept {      // 5b. move assignment
        if (this != &o) {                         //     guard against self-move
            delete[] data;                        //     free what we hold
            data = o.data;                        //     steal o's pointer
            o.data = nullptr;                     //     leave o safe to destroy
        }
        return *this;
    }
};

4. How std::vector Uses Moves

When a std::vector runs out of capacity, it allocates a bigger buffer and transfers the existing elements into it. If your type's move constructor is marked noexcept, the vector moves each element (cheap). If it isn't, the vector copies them instead — it needs the strong exception guarantee, and a move that might throw could leave it in a broken state. That one keyword is the difference between fast and slow growth.

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

struct Item {
    string name;
    Item(string n) : name(n) { cout << name << ": built" << endl; }
    Item(const Item& o) : name(o.name) { cout << name << ": COPIED" << endl; }
    Item(Item&& o) noexcept : name(move(o.name)) { cout << "moved" << endl; }
};

int main() {
    vector<Item> v;
    v.reserve(2);               // room for 2 — no reallocation yet
    cout << "push #1" << endl;  v.push_back(Item("one"));
   
...

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

// 🎯 MINI-CHALLENGE: a move-aware "Document" class
// 1. Give it a private  vector<string> lines;  and a  string title;
// 2. Constructor: Document(string t) sets title and prints "<t>: created".
// 3. Add a COPY constructor that prints "<title>: copied".
// 4. Add a MOVE constructor (mark it noexcept) that move()s both members
//    and prints "<title>: moved".
// 5. In main(): build d1, do  Document d2 = d1;        
...