C++ Move Semantics

移动语义（Move Semantics）是 C++11 引入的特性，核心目的：在资源传递时“窃取”而非“拷贝”，把 O(n) 的深拷贝降为 O(1) 的指针转移。适用于动态内存、文件句柄、智能指针等可窃取的资源。

类比“搬家”：不是复制一套家具，而是直接把原家具搬走，让原房变空。

背景：拷贝语义的代价

C++98 中对象传递依赖拷贝语义——返回局部对象会触发拷贝构造，复制全部资源。对大对象（如 std::vector）开销巨大。

class Resource {
    int* data;
    size_t size;
public:
    Resource(size_t s) : size(s), data(new int[s]) {}
    ~Resource() { delete[] data; }
    // 拷贝构造：深拷贝，O(n)
    Resource(const Resource& other) : size(other.size), data(new int[other.size]) {
        std::copy(other.data, other.data + size, data);
    }
};

返回 Resource 时会拷贝整个数组——很低效。

核心概念：右值引用

移动语义建立在右值引用 T&& 之上，它区分了值的类别：

左值（lvalue）：有名称、可取地址（如变量 x），持久存在。
右值（rvalue）：临时的、无名称的对象（如字面量 42、函数返回的临时值），即将销毁。

T&& 只绑定右值，从而为右值提供专属的移动操作，不影响左值的拷贝。

值类别细究

C++11 把表达式细分为三类，理解它们有助于判断何时触发拷贝/移动：

prvalue（纯右值）：没有“主人”的临时值，如字面量 42、std::string("hello")、表达式计算结果。
xvalue（将亡值）：有主人但即将被销毁、可安全转移资源的对象，如 std::move(x) 的结果。
glvalue（泛左值）：prvalue 之外，有标识的表达式（lvalue + xvalue）。

关键区别：prvalue 是纯粹的临时计算结果；xvalue 是“有主但将死”的对象，强调资源转移意图。两者在返回值语境中都会触发移动构造（若存在）。

绑定规则

左值 → T& 或 const T&
右值 → T&& 或 const T&（const T& 会延长临时对象生命周期，但不触发移动）
模板中的 T&& 可能是通用引用（见下文）

通用引用（Forwarding Reference）

写法 template<typename T> void f(T&& t) 看似右值引用，实为通用引用，行为由类型推导决定：

传入左值：T 推导为 U&，引用折叠后参数为 U&（左值引用）
传入右值：T 推导为 U，参数为 U&&（右值引用）

这是完美转发的基础。

std::move 与 std::forward

std::move 本质是 static_cast<T&&>(x)，仅“标记”允许移动，不做实际移动。移动后源对象处于“有效但未指定”状态，不可再依赖其值。
std::forward 用于模板中完美转发：T 是左值引用时保持左值，否则保持右值。
误用 std::move 会把仍需使用的对象置空，产生隐蔽 bug。

实现移动：移动构造与移动赋值

支持移动的类需定义两个特殊成员函数：

class Resource {
    int* data;
    size_t size;
public:
    Resource(size_t s) : size(s), data(new int[s]) {}

    // 拷贝构造：深拷贝
    Resource(const Resource& other) : size(other.size), data(new int[other.size]) {
        std::copy(other.data, other.data + size, data);
    }

    // 移动构造：窃取资源 + 源对象置空
    Resource(Resource&& other) noexcept : size(other.size), data(other.data) {
        other.data = nullptr;
        other.size = 0;
    }

    // 移动赋值：先释放旧资源，再窃取
    Resource& operator=(Resource&& other) noexcept {
        if (this != &other) {
            delete[] data;
            size = other.size;
            data = other.data;
            other.data = nullptr;
            other.size = 0;
        }
        return *this;
    }

    ~Resource() { delete[] data; }
};

要点：

noexcept 必不可少——容器（如 vector 扩容/重排）只在移动 noexcept 时才会选择移动而非拷贝，以保强异常保证。
移动赋值要处理自赋值并释放旧资源。

std::move：强制转换为右值

右值引用只绑定右值，但有时需要移动左值（如局部变量）。std::move（<utility>）将左值静态转换为右值引用，仅标记“可移动”。

Resource createResource(size_t s) {
    Resource r(s);   // 局部对象（左值）
    return r;        // 自动移动（NRVO + 移动语义）
}

返回局部对象时编译器自动按右值处理，无需手写 return std::move(r);——显式写反而会抑制 NRVO。

编译器层与内存层：移动到底做了什么

移动语义“零开销”的真相要分两层看：编译器层只做选择，内存层才做搬运。

编译器层：全是编译期决策，不生成移动指令

std::move 是个空操作：它本质是 static_cast<T&&>(x)，纯粹在编译期改变表达式的值类别（把左值标记为右值），不产生任何机器码、不做任何搬运。它只是打开了“允许调用移动重载”的门。
重载决议：当同时存在 T(const T&)（拷贝构造）与 T(T&&)（移动构造）时，编译器依据实参的值类别选其一——右值匹配 T&&，左值匹配 const T&。这是编译期选择，运行时无分支判断。
返回值的两次降级：返回局部对象时编译器按“能省则省”顺序处理：
1. NRVO（命名返回值优化）：直接在调用者的内存空间构造对象，零拷贝零移动，连移动构造都不调用。
2. NRVO 不可行时退化为隐式移动：编译器把返回的局部对象当作右值，调用移动构造（若存在）。
3. 既无 NRVO 也无移动构造，才回退到拷贝。
  这就是为什么显式 return std::move(r); 反而有害——它禁止了 NRVO，强制走第 2 步。
完美转发也是编译期：std::forward<T> 同样是 static_cast，引用折叠在编译期完成，运行时零开销。

内存层：窃取由谁、怎么做到

先澄清一个关键认知：搬指针这件事，既不是 std::move 干的，也不是编译器干的，而是你手写的移动构造/赋值函数体里那几行赋值语句干的。

std::move 只负责“贴标签”——把实参标记成右值，让重载决议选中 T(T&&)，它本身不碰内存。
编译器只负责“选函数 + 生成调用”——在调用点生成一条 call Resource::Resource(Resource&&) 的机器指令，把源对象地址传进去。它不关心函数体里到底有没有真搬指针。
真正的“窃取”发生在你写的函数体内：

Resource(Resource&& other) noexcept
    : size(other.size)      // 1. 复制长度字段（8 字节）
    , data(other.data) {    // 2. 复制指针字段（把堆地址抄过来）
    other.data = nullptr;   // 3. 把源指针清空
    other.size = 0;         // 4. 把源长度清零
}

指针赋值的物理本质

data 是个 int*，在 64 位机器上就是栈/对象内存里一个 8 字节的槽，存放的是一个堆地址（如 0x7f8a3c001000）。other.data 赋给 this->data，就是把那 8 字节的地址值抄一份到 this 的槽里。

flowchart LR
    subgraph before["移动前"]
        direction TB
        bo["源对象 other<br/>data = 0x..1000<br/>size = 1000000"]
        bh[("堆：100万个 int<br/>0x..1000")]
        bo -.->|持有| bh
    end

    subgraph after["移动后"]
        direction TB
        ao["源对象 other<br/>data = nullptr<br/>size = 0"]
        at["新对象 this<br/>data = 0x..1000<br/>size = 1000000"]
        ah[("同一块堆：100万个 int<br/>0x..1000<br/>字节未动")]
        at -.->|持有| ah
        ao -.->|nullptr 不再指向| ah
    end

    before == "搬 8 字节指针<br/>堆内存原地不动" ==> after

关键点：堆上那 100 万个 int 一个字节都没碰，也没分配新内存——搬的只是 8 字节的地址。随后 other.data = nullptr 把源的那个地址槽清空，这一步至关重要：之后 other 析构时 delete[] nullptr 是安全的空操作；若不清空，源析构会 delete[] 同一块堆内存，新对象立刻悬垂（double-free 的反面）。

为什么是 O(1)

拷贝的 O(n) 花在“分配 n×4 字节新堆 + 逐个复制 n 个元素”上。
移动的 O(1) 只花在“抄固定几个字段（指针 + 长度 + 容量）”上，字段数量与元素个数无关。vector 无论存 10 个还是 1000 万个，移动都是搬 3 个字段：指针、size、capacity。

移动赋值还多一步：先放旧货

移动赋值 operator= 需要先释放 this 原有的旧资源（否则内存泄漏），再窃取源：

Resource& operator=(Resource&& other) noexcept {
    if (this != &other) {          // 防自赋值：移动自己会把资源先删后抄到空
        delete[] data;             // 1. 释放自己的旧堆
        data = other.data;         // 2. 抄源指针
        size = other.size;
        other.data = nullptr;      // 3. 源置空，避免双析构
        other.size = 0;
    }
    return *this;
}

`noexcept` 与容器的关系

搬指针（几个赋值、一次 delete）几乎不会抛异常，所以移动构造/赋值应标 noexcept。这并非仅是“良好习惯”：标准容器在扩容/重排时只在移动 noexcept 时才敢用移动，否则退回拷贝。原因是容器扩容需要强异常保证——若移动中途抛异常，会留下“搬了一半”的损坏对象，无法回滚；而拷贝失败时源对象完好，可以安全回滚。noexcept 是你对容器的一个承诺：“这几步赋值不会失败”，容器才放心地用移动代替拷贝。

何时“移动”退化为“拷贝”

没有可窃取资源时移动毫无意义。对于纯数据类型（如 int、struct Point{int x,y;} 这类 trivially copyable 类型），没有堆指针可搬，移动构造要么不存在、要么与拷贝等价——编译器对它们直接做位拷贝。移动语义只对持有外部资源的类型（动态内存、文件句柄、锁、socket）才有真实收益。

性能对比

std::vector 内置移动支持：

std::vector<int> large(1000000, 42);

std::vector<int> copy = large;             // 拷贝：复制百万元素
std::vector<int> moved = std::move(large); // 移动：仅转移指针，几乎零开销

std::cout << large.size();                 // 0：源对象已空

拷贝需数毫秒，移动只需微秒级。

完美转发

完美转发让泛型代码在传递参数时完整保持其左/右值性与常量性。它依赖引用折叠 + 通用引用 + std::forward 三者配合（缺一不可）。

引用折叠规则

编译器遇到组合引用时按规则折叠：

组合	结果
`T& &`、`T& &&`、`T&& &`	`T&`
`T&& &&`	`T&&`

口诀：只要出现左值引用就折叠为左值引用，只有两个右值引用才得右值引用。

推导与转发

template<typename T>
void wrapper(T&& arg) {
    target(std::forward<T>(arg));  // forward 按 T 保持值类别
}

std::string s = "hello";
wrapper(s);            // T=string&,  forward → 左值
wrapper(std::move(s)); // T=string,   forward → 右值

典型应用

// 完美构造代理：一个构造函数转发所有参数
class MyClass {
    SomeComplexType data_;
public:
    template<typename... Args>
    MyClass(Args&&... args) : data_(std::forward<Args>(args)...) {}
};

// make_unique 的核心就是完美转发
template<typename T, typename... Args>
std::unique_ptr<T> make_unique(Args&&... args) {
    return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
}

优势：零开销（编译期完成）、自动选最优传参方式、一个接口处理多种参数组合。

常见陷阱

template<typename T>
void bad_wrapper(T&& arg) {
    target(arg);  // 错误：具名变量 arg 总是左值，丢失了右值性！
    target(std::forward<T>(arg));  // 正确
}

通用引用与右值引用的区别：T&&（模板推导）是通用引用；std::vector<T>&&（类型已固定，无推导）是普通右值引用。

规则与最佳实践

Rule of Five / Zero：定义了析构、拷贝构造、拷贝赋值，就应同时定义移动构造/赋值。现代 C++ 更倾向 Rule of Zero——用 RAII 类型（std::unique_ptr 等）让编译器自动生成正确行为。
强制不可拷贝：对互斥锁等独占资源，delete 拷贝、default 移动。
移动必加 noexcept：否则容器不会用移动。
NRVO 优先：返回局部对象时直接返回，别加 std::move（会抑制 NRVO）。
不要返回 T&&：通常导致悬垂引用；直接返回对象即可。
移动后状态：源对象“有效但未指定”，勿依赖其值，也别在循环中对同一对象重复移动后使用。

拷贝 vs 移动对比

方面	拷贝语义 (C++98)	移动语义 (C++11+)
性能	O(n) 复制全部数据	O(1) 指针转移
适用	共享资源 (`shared_ptr`)	独占资源 (`unique_ptr`)
语法	`const T&` 参数	`T&&` 参数 + `std::move`
典型	`std::string` 深拷贝	`std::vector` 移动 realloc