右值引用与移动语义

第 1 章 学习目标与导论

1.1 本章在 C++ 知识体系中的位置

右值引用（rvalue reference，由 Howard Hinnant、Bjarne Stroustrup 与 Bjarne Kozicki 于 2008 年在 ISO 提案 N1690 中正式定义，记为 T&&）与移动语义（move semantics，由 Howard Hinnant 等于 2002 年提案 N1377 提出，将「资源所有权转移」表达为语言级语法，与「拷贝语义」（copy semantics）相对）是 C++11 引入的两项关键语言特性，位于 C++ 知识体系的「值语义层」。向上承接 cpp/指针 与 cpp/引用 中的指针/引用机制，向下衔接 cpp/智能指针详解、cpp/RAII资源管理、cpp/模板元编程、cpp/Lambda表达式 等现代 C++ 关键特性。

学习本章前，读者应当已经掌握：

• cpp/概述与现代标准：C++11/14/17/20/23 的标准演进
• cpp/基础语法：变量声明、作用域、控制流
• cpp/数据类型详解：基本类型、模板基础
• cpp/指针：裸指针的内存模型与算术运算
• cpp/引用：左值引用、const 引用的绑定规则
• cpp/面向对象基础：构造、析构、拷贝构造与拷贝赋值

掌握本章后，读者将能够阅读 cpp/智能指针详解、cpp/RAII资源管理、cpp/模板元编程、cpp/STL容器与迭代器 等高级主题，并具备在生产代码中正确编写移动构造、完美转发与泛型工厂的能力。

1.2 学习目标

本章遵循 Bloom 分类法，按认知层级递进组织学习目标：

1. 记忆（Remember）：复述值类别（value categories）完整分类树（lvalue/prvalue/xvalue/rvalue/glvalue）的判别准则与 C++11 之后的右值引用语法形态。
2. 理解（Understand）：解释移动语义（move semantics）的形式化定义、状态机模型与「moved-from」对象的不变量约束。
3. 应用（Apply）：使用 std::move、std::forward、移动构造、移动赋值编写异常安全且零拷贝的资源转移代码。
4. 分析（Analyze）：对比引用折叠规则（reference collapsing，C++11 引入的模板推导规则，规定「右值的右值引用仍为右值引用，其余组合均折叠为左值引用」，是完美转发的语法基础）与 T&& 模板推导规则的代数性质，推导完美转发的正确性。
5. 评估（Evaluate）：评估复制省略（copy elision）、返回值优化（RVO/NRVO）与移动语义的协同与冲突，判断编译器优化边界。
6. 设计（Apply/Create）：设计基于完美转发的工厂函数、泛型容器、std::make_unique/make_shared 与 C++20 ranges 的生产级抽象。
7. 创造（Create）：构造支持 ABI 稳定性、异常安全与多态转发的现代 C++ 资源管理架构。

1.3 阅读建议

• 零基础读者：先通读第 2、3、5 章，建立值类别与移动语义的直观认识；再回看第 6-9 章深入推导规则。
• 有 C++03 经验读者：重点关注第 2 章历史动机与第 6 章 std::move/std::forward 的形式化语义。
• 进阶读者：直接研读第 8 章完美转发、第 9 章引用折叠与第 12 章工程实践，再延伸至第 13 章案例研究。
• 应试/面试读者：第 5、6、9、11 章为高频考点；第 15 章习题覆盖 4 类题型。

第 2 章 历史动机与演进

2.1 1980s-2000：C++03 的「值语义」枷锁

C++ 的初始设计哲学是「值语义优先」：所有对象默认按值传递、按值返回、按值拷贝。这一选择带来两个深远影响：

1. 可表达性受限：资源拥有型类型（如 std::vector、文件句柄封装类、数据库连接）只能通过「拷贝构造 + 析构」表达所有权转移，代价高昂。
2. STL 容器性能瓶颈：容器扩容时需逐元素调用拷贝构造，对于持有大量动态分配内存的对象（如 vector<string>）极其低效。

考虑 C++03 时代的资源拥有型类：

#include <vector>
#include <cstring>
#include <iostream>

// C++03 风格：仅有拷贝构造
class String03 {
    char* data_;
    size_t size_;
public:
    explicit String03(const char* s) : size_(std::strlen(s)) {
        data_ = new char[size_ + 1];
        std::strcpy(data_, s);
    }
    // 拷贝构造：必须深拷贝
    String03(const String03& other) : size_(other.size_) {
        data_ = new char[size_ + 1];
        std::strcpy(data_, other.data_);
    }
    String03& operator=(const String03& other) {
        if (this != &other) {
            delete[] data_;
            size_ = other.size_;
            data_ = new char[size_ + 1];
            std::strcpy(data_, other.data_);
        }
        return *this;
    }
    ~String03() { delete[] data_; }
    const char* c_str() const { return data_; }
};

int main() {
    std::vector<String03> v;
    // 触发扩容时，所有元素被深拷贝，O(n) 内存分配 + O(n) 字符串拷贝
    for (int i = 0; i < 100; ++i) {
        v.push_back(String03("hello"));  // 临时对象构造 + 拷贝构造 + 析构
    }
    std::cout << v[0].c_str() << "\n";  // 输出: hello
    return 0;
}

在 C++03 下，即使临时对象的资源在拷贝后立即被销毁，程序员也无法表达「资源所有权转移」的意图，必须进行无意义的深拷贝。这是移动语义产生的最直接动机。

2.2 2002-2008：N1377 与移动语义的诞生

2002 年，Howard Hinnant 向 ISO C++ 委员会提交提案 N1377《A Proposal to Add Move Semantics Support to the C++ Language》，首次系统化提出：

• 引入新的引用语法 T&& 用于绑定「即将销毁」的对象；
• 引入移动构造函数（move constructor）与移动赋值运算符（move assignment operator）；
• 容器可利用移动构造在扩容时「掠夺」资源而非深拷贝。

2008 年，Hinnant、Stroustrup 与 Kozicki 联合提交 N1690《A Brief Introduction to Rvalue References》，将提案体系化为标准文本。C++11（ISO/IEC 14882:2011）正式纳入右值引用与移动语义，标志现代 C++ 资源管理范式的开端。

2.3 2011-2014：C++11/14 的完善

C++11 引入的关键特性：

• T&& 右值引用语法
• 移动构造 T(T&&) 与移动赋值 T& operator=(T&&)
• std::move 与 std::forward 工具函数
• 标准库容器全面支持移动语义（vector::push_back(T&&) 等右值重载）
• 完美转发（perfect forwarding，由 Howard Hinnant 等于 2002-2008 年提案体系化，目标是「泛型函数将参数的值类别与 const 性原封不动地转发给目标函数」；「完美」指零开销、零语义损耗）

C++14（2014）补完 std::make_unique，填补 C++11 遗漏：

// C++11 遗漏：make_unique 缺失
std::unique_ptr<int> p1(new int(42));  // C++11 写法，存在异常安全隐患

// C++14 补完
auto p2 = std::make_unique<int>(42);   // C++14 推荐写法，异常安全

2.4 2017-2023：值类别的精细化为 C++17 强制省略

C++11/14 期间，值类别（value categories）的术语体系较为模糊。C++17 对值类别进行系统重构，引入「prvalue」「xvalue」「glvalue」的精确划分，并强制「guaranteed copy elision」（保证复制省略）：

#include <string>

struct A {
    A() = default;
    A(const A&) { /* 拷贝 */ }
    A(A&&) { /* 移动 */ }
};

A make_a() {
    return A();   // C++11/14: 编译器可省略（可选优化）；C++17: 强制省略
}

int main() {
    A a = make_a();  // C++17: 无临时对象被构造，无拷贝/移动调用
    return 0;
}

C++20 引入 concepts 与 ranges，进一步要求泛型代码精确处理值类别（如 std::ranges::views::filter 的迭代器需正确转发 operator* 的返回类型）。

C++23 引入 std::forward_like<T>(x)，将 std::forward 的语义推广到「按某个类型的值类别转发另一个表达式」：

#include <utility>
#include <string>
#include <tuple>

// C++23 std::forward_like：按「封装类 T 的值类别」转发「成员 x」
template<typename Self>
auto&& get_name(this Self&& self) {
    return std::forward_like<Self>(self.name_);  // self 为 rvalue 时成员为 rvalue
}

struct Person {
    std::string name_;
};
// 调用：Person p; auto n = get_name(p);          // n 为 const std::string&
// 调用：auto n = get_name(std::move(p));          // n 为 std::string&&

2.5 演进时间线

timeline
    title C++ 移动语义演进时间线
    section 1985-2002 前夜
        1985 : C++ 第一个商用版本
        1998 : C++98 标准发布
        2002 : N1377 提出移动语义
    section 2008-2011 诞生
        2008 : N1690 系统化右值引用
        2011 : C++11 引入 T&& 与 std::move
        2011 : 完美转发与引用折叠确立
    section 2014-2017 成熟
        2014 : C++14 补完 make_unique
        2015 : Scott Meyers 区分 forwarding reference
        2017 : C++17 强制复制省略 + 值类别精细化
    section 2020-2023 完善
        2020 : C++20 ranges 与 concepts 要求精确值类别
        2023 : C++23 std::forward_like 与 deducing this

第 3 章 形式化定义

3.1 值类别的代数定义

按 ISO/IEC 14882:2023 [basic.lval]，C++ 表达式按两个正交性质划分：

• identity（同一性）：表达式是否关联到具名对象或可寻址存储。形式化定义：

• movability（可移动性）：表达式是否可被 std::move 或等价的 static_cast<T&&> 掠夺资源。形式化定义：

由这两个性质笛卡尔积得到 5 个值类别：

代数关系：

3.2 右值引用的形式化语法产生式

C++11 引入的右值引用语法产生式（简化版）：

reference-declaration:
    decl-specifier-seq declarator = initializer

declarator:
    ptr-operator declarator
    noptr-declarator parameters-and-qualifiers trailing-return-type

ptr-operator:
    "&" attribute-specifier-seq(opt)
    "&&" attribute-specifier-seq(opt)        ← 新增右值引用
    nested-name-specifier "*" attribute-specifier-seq(opt)

类型层面的形式化定义：

即「若 e 是右值类型为 T，则 T&& r = e 是合法绑定」。反之，左值引用 T& r = e 要求 e 为左值（或 const T& 兼容右值，属于例外规则）。

3.3 移动构造与移动赋值的语义

移动构造函数形式化签名：

其语义约束（[utility.arg.requirements]）：

1. 资源掠夺：将源对象 src 的内部资源（指针、句柄等）转移到目标 dst；
2. 源对象有效但未指定：移动完成后 src 处于「valid but unspecified」状态，可安全析构、可赋值，但具体值不可依赖；
3. 不抛异常：理想情况下移动构造应标记 noexcept，否则标准库容器在扩容时退化为拷贝以保证强异常安全。

形式化后置条件：

其中 destructor_safe 表示源对象可被析构而不引发未定义行为。

3.4 std::move 与 std::forward 的形式化语义

std::move 的形式化定义：

注意 std::move 实际上不产生任何运行期操作，仅做编译期类型转换。其返回类型 T&& 是 xvalue 表达式。

std::forward 的形式化定义：

注意 std::forward<T> 必须显式指定模板参数 T，且其行为依赖 T 的推导结果（仅在 forwarding reference 上下文中正确）。

3.5 状态机模型

std::move 操作可建模为对象状态机：

stateDiagram-v2
    [*] --> Constructed
    Constructed --> MovedFrom : std::move(o) + move ctor
    MovedFrom --> Constructed : re-assign
    MovedFrom --> [*] : destructor (safe)
    Constructed --> [*] : destructor

    note right of MovedFrom
        valid but unspecified
        - 可安全析构
        - 可赋值
        - 不可解引用悬空成员
    end note

状态不变量：

第 4 章 理论推导与复杂度分析

4.1 复杂度对比：拷贝 vs 移动

设类型 T 持有 n 字节动态分配资源，则：

• 拷贝构造的时间复杂度：$\Theta(n)$（需分配新内存 + 复制内容）
• 移动构造的时间复杂度：$\Theta(1)$（仅交换指针与元数据）

形式化对比：

对 std::vector<T>::resize 从容量 m 扩容到 2m 的总开销：

• C++03（仅拷贝）：$\sum_{i=0}^{\log_2 m} 2^i \cdot n = (2m - 1) \cdot n \in \Theta(m \cdot n)$
• C++11+（移动，且 noexcept）：$\sum_{i=0}^{\log_2 m} 2^i \cdot 1 = 2m - 1 \in \Theta(m)$

即对持有大量资源的元素，移动语义将容器扩容从 $O(m \cdot n)$ 降至 $O(m)$，量级优化。

4.2 引用折叠的代数性质

引用折叠规则可表示为二元运算表：

形式化为布尔代数，令 L = &（左值引用），R = &&（右值引用），运算符 ⊕ 表示折叠：

此运算在集合 {L, R} 上构成半群，单位元不存在（折叠至少需 2 个引用），且满足：

即「只要有一个 L，结果为 L；仅当两者均为 R，结果为 R」。这一规则保证 forwarding reference 在 lvalue 实参下退化为 lvalue 引用，rvalue 实参下保持 rvalue 引用。

4.3 完美转发的正确性证明

定理：设函数模板 template<typename T> void f(T&& x) { g(std::forward<T>(x)); }，对任意表达式 e 调用 f(e)，则 g 接收的实参值类别与 e 的值类别一致。

证明：

按 [temp.deduct.call] 的 forwarding reference 推导规则：

• 若 e 为 lvalue，则 T 推导为 T&，经折叠 T&& = T& && = T&，函数形参 x 类型为 T&，即 lvalue 引用。
• 若 e 为 rvalue（xvalue 或 prvalue），则 T 推导为 T（非引用），函数形参 x 类型为 T&&，即 rvalue 引用。

考虑 std::forward<T>(x) 的展开（按 [forward] 标准）：

template<typename T>
constexpr T&& forward(remove_reference_t<T>& t) noexcept {
    return static_cast<T&&>(t);
}

情形 1：e 为 lvalue，T = U&，则 T&& = U& && = U&（折叠），std::forward<U&>(x) 返回 static_cast<U&>(x)，类型为 U&，即 lvalue。值类别保持。

情形 2：e 为 rvalue，T = U，则 T&& = U&&，std::forward<U>(x) 返回 static_cast<U&&>(x)，类型为 U&&，即 xvalue。值类别保持。

故 g 接收的实参值类别与 e 一致。$\square$

4.4 复制省略与移动语义的交互

C++17 引入的「guaranteed copy elision」并非真正「省略」构造，而是改变 prvalue 的语义：

• C++14 之前：prvalue 表达式先构造一个临时对象，再以此初始化目标对象（编译器可省略此拷贝）。
• C++17 起：prvalue 表达式不再构造临时对象，而是「延迟物化」（deferred materialization），仅在需要时（如绑定到引用、作为函数实参）才物化为临时对象。

形式化：

这意味着：C++17 起，prvalue 初始化对象时既无拷贝也无移动，连移动构造函数都不调用。这是「比移动更快」的优化。

#include <iostream>

struct Tracer {
    Tracer() { std::puts("default"); }
    Tracer(const Tracer&) { std::puts("copy"); }
    Tracer(Tracer&&) { std::puts("move"); }
    ~Tracer() { std::puts("dtor"); }
};

Tracer make() { return Tracer(); }  // C++17 起强制省略

int main() {
    Tracer t = make();  // C++17 输出: default / dtor（无 copy/move）
    return 0;
}

第 5 章 左值、右值与值类别完整分类

5.1 值类别分类树

flowchart TD
    E[expression 表达式] --> GL[glvalue<br/>has identity]
    E --> R[rvalue<br/>movable]
    GL --> L[lvalue<br/>identity, not movable]
    GL --> X[xvalue<br/>identity, movable]
    R --> X
    R --> PR[prvalue<br/>not identity, movable]

5.2 lvalue 判别准则

以下表达式为 lvalue：

#include <string>

std::string g = "global";

void f(std::string& s) { /* s 是 lvalue */ }

int main() {
    std::string x = "hello";       // x 是 lvalue
    std::string& ref = x;          // ref 是 lvalue（绑定到 lvalue 的引用）
    f(x);                          // 函数形参 s 是 lvalue

    int arr[5];
    arr[2];                        // 下标结果是 lvalue
    *x.c_str();                    // 解引用结果是 lvalue
    ++x;                           // 前置自增返回 lvalue
    x = "world";                   // 赋值返回 lvalue（左操作数的引用）

    std::string* p = &g;
    *p;                            // 解引用结果是 lvalue

    std::string std::string:: *pmf = nullptr;
    // g.*pmf;                    // 成员访问结果是 lvalue

    return 0;
}

5.3 prvalue 判别准则

#include <string>

int main() {
    42;                            // 字面量是 prvalue（字符串字面量除外）
    3.14;                          // 浮点字面量是 prvalue
    true;                          // bool 字面量是 prvalue
    nullptr;                       // nullptr 是 prvalue

    int x = 1, y = 2;
    x + y;                         // 算术运算结果是 prvalue
    x == y;                        // 比较运算结果是 prvalue
    !x;                            // 逻辑非结果是 prvalue
    -x;                            // 一元负号结果是 prvalue

    std::string("tmp");            // 显式类型构造（非引用）是 prvalue
    static_cast<int>(3.14);        // static_cast 结果是 prvalue
    int(3.14);                     // 函数式转型是 prvalue
    return 0;                      // return 语句中的非引用表达式是 prvalue
}

注意：字符串字面量 "hello" 是 lvalue 而非 prvalue（类型为 const char[N]，可取地址）。

5.4 xvalue 判别准则

xvalue（expiring value，全称「eXpiring value」，指「即将失效的值」）由以下表达式产生：

#include <utility>
#include <string>

struct A { int data; };

A make_a() { return A{}; }

int main() {
    A a;
    A&& r1 = std::move(a);          // std::move(a) 是 xvalue
    A&& r2 = static_cast<A&&>(a);   // static_cast<A&&> 是 xvalue

    A&& r3 = make_a();              // C++17 前：make_a() 是 prvalue，但绑定到 rvalue 引用时
                                    // 会触发「物化转换」（materialization conversion）
                                    // 转为 xvalue；C++17 后保持 prvalue 语义

    a.data;                         // 成员访问：a 是 lvalue，结果 lvalue
    std::move(a).data;              // 成员访问：std::move(a) 是 xvalue，结果 xvalue

    // 函数返回右值引用
    auto f = []() -> int&& { static int x = 1; return std::move(x); };
    f();                            // 返回 rvalue reference 的函数调用是 xvalue

    // 下标运算对数组右值
    using Arr = int[3];
    Arr&& arr_ref = std::move(*reinterpret_cast<Arr*>(nullptr)); // 仅类型演示
    return 0;
}

5.5 值类别判定流程

判定任意表达式 e 的值类别的流程：

flowchart TD
    A[表达式 e] --> B{是否可取地址？}
    B -- 是 --> C{是否 std::move / 返回 rvalue ref / 对 rvalue 的成员访问？}
    B -- 否 --> D[prvalue]
    C -- 是 --> E[xvalue]
    C -- 否 --> F[lvalue]
    D --> G[rvalue]
    E --> G
    E --> H[glvalue]
    F --> H

5.6 值类别测试代码

#include <type_traits>
#include <utility>
#include <iostream>
#include <string>

// 利用 decltype 与函数重载判定值类别
template<typename T> char& is_lvalue(T&) { static char c; return c; }
template<typename T> short& is_lvalue(T&&) { static short s; return s; }

#define VALUE_CATEGORY(expr) \
    (sizeof(is_lvalue(expr)) == sizeof(char) ? "lvalue" : "rvalue")

int g_int = 0;
int& lref() { return g_int; }
int&& rref() { return std::move(g_int); }
int prval() { return 42; }

int main() {
    int x = 0;
    std::cout << VALUE_CATEGORY(x) << "\n";                // 输出: lvalue
    std::cout << VALUE_CATEGORY(std::move(x)) << "\n";     // 输出: rvalue
    std::cout << VALUE_CATEGORY(42) << "\n";               // 输出: rvalue
    std::cout << VALUE_CATEGORY(lref()) << "\n";           // 输出: lvalue
    std::cout << VALUE_CATEGORY(rref()) << "\n";           // 输出: rvalue
    std::cout << VALUE_CATEGORY(prval()) << "\n";          // 输出: rvalue
    std::cout << VALUE_CATEGORY("hello") << "\n";          // 输出: lvalue（字符串字面量）
    std::cout << VALUE_CATEGORY(x + 1) << "\n";            // 输出: rvalue
    return 0;
}

5.7 字面量值类别细节

字符串字面量是 lvalue 是因为：标准规定其存活于静态存储区，可被取地址，多次出现的相同字面量可能指向同一存储。

第 6 章 右值引用与移动语义

6.1 右值引用基础

右值引用 T&& 是 C++11 引入的新引用类型，专门用于绑定「即将销毁」的对象：

#include <iostream>

int main() {
    int&& r = 42;        // r 是右值引用，绑定到 prvalue 42
    // int& l = 42;      // 错误：非 const 左值引用不能绑定右值
    const int& cl = 42;  // 合法：const 左值引用可绑定右值（兼容规则）

    std::cout << r << "\n";  // 输出: 42
    r = 100;                  // 右值引用变量本身是 lvalue，可赋值
    std::cout << r << "\n";  // 输出: 100
    return 0;
}

注意：右值引用变量本身是 lvalue（具名对象），不能再次隐式绑定到右值引用形参。这是「完美转发」需要 std::forward 的根本原因。

6.2 右值引用作为函数参数

#include <iostream>
#include <string>
#include <utility>

// 重载集：根据实参值类别选择不同函数
void process(int& x)        { std::puts("lvalue"); }
void process(const int& x)  { std::puts("const lvalue"); }
void process(int&& x)       { std::puts("rvalue"); }

int main() {
    int a = 1;
    const int b = 2;

    process(a);              // 输出: lvalue
    process(b);              // 输出: const lvalue
    process(3);              // 输出: rvalue
    process(std::move(a));   // 输出: rvalue
    return 0;
}

6.3 移动构造函数

#include <cstring>
#include <utility>
#include <iostream>

class String {
    char* data_;
    size_t size_;
public:
    // 默认构造
    String() : data_(nullptr), size_(0) {}

    // 参数化构造
    explicit String(const char* s) : size_(std::strlen(s)) {
        data_ = new char[size_ + 1];
        std::strcpy(data_, s);
    }

    // 拷贝构造：深拷贝
    String(const String& other) : size_(other.size_) {
        data_ = new char[size_ + 1];
        std::strcpy(data_, other.data_);
        std::puts("copy ctor");
    }

    // 移动构造：掠夺资源，源对象置空
    String(String&& other) noexcept
        : data_(other.data_), size_(other.size_) {
        other.data_ = nullptr;
        other.size_ = 0;
        std::puts("move ctor");
    }

    // 拷贝赋值
    String& operator=(const String& other) {
        if (this != &other) {
            delete[] data_;
            size_ = other.size_;
            data_ = new char[size_ + 1];
            std::strcpy(data_, other.data_);
        }
        return *this;
    }

    // 移动赋值
    String& operator=(String&& other) noexcept {
        if (this != &other) {
            delete[] data_;
            data_ = other.data_;
            size_ = other.size_;
            other.data_ = nullptr;
            other.size_ = 0;
        }
        return *this;
    }

    ~String() { delete[] data_; }

    const char* c_str() const { return data_ ? data_ : ""; }
    size_t size() const { return size_; }
};

int main() {
    String a("hello");
    String b = a;                 // 输出: copy ctor
    String c = std::move(a);      // 输出: move ctor
    std::cout << "a='" << a.c_str() << "'\n";  // 输出: a=''（moved-from，安全但未指定）
    std::cout << "c='" << c.c_str() << "'\n";  // 输出: c='hello'
    return 0;
}

6.4 移动赋值与自赋值

#include <utility>
#include <vector>

class Buffer {
    std::vector<int> data_;
public:
    Buffer& operator=(Buffer&& other) noexcept {
        if (this != &other) {           // 防自赋值
            data_ = std::move(other.data_);
        }
        return *this;
    }
};

// C++11 起推荐的「copy-and-swap」惯用法可实现拷贝/移动赋值统一
class BufferCAS {
    std::vector<int> data_;
public:
    BufferCAS(const BufferCAS& other) : data_(other.data_) {}
    BufferCAS(BufferCAS&& other) noexcept : data_(std::move(other.data_)) {}

    // 统一赋值运算符：按值传入，编译器根据实参值类别选择拷贝/移动构造
    BufferCAS& operator=(BufferCAS other) noexcept {
        data_ = std::move(other.data_);  // 复用移动语义
        return *this;
    }
};

6.5 noexcept 的关键作用

noexcept 不仅是性能提示，更是标准库容器扩容的「调度开关」：

#include <vector>
#include <iostream>
#include <utility>

class Tracker {
    int* p_;
public:
    Tracker() : p_(new int(0)) {}
    ~Tracker() { delete p_; }
    Tracker(const Tracker& o) : p_(new int(*o.p_)) { std::puts("copy"); }

    // 缺失 noexcept 的移动构造
    Tracker(Tracker&& o) : p_(o.p_) { o.p_ = nullptr; std::puts("move"); }
};

class TrackerNoexcept {
    int* p_;
public:
    TrackerNoexcept() : p_(new int(0)) {}
    ~TrackerNoexcept() { delete p_; }
    TrackerNoexcept(const TrackerNoexcept& o) : p_(new int(*o.p_)) { std::puts("copy"); }

    // noexcept 移动构造
    TrackerNoexcept(TrackerNoexcept&& o) noexcept : p_(o.p_) { o.p_ = nullptr; std::puts("move"); }
};

int main() {
    std::vector<Tracker> v1;
    v1.reserve(2);
    v1.emplace_back();
    v1.emplace_back();
    v1.emplace_back();   // 触发扩容：因 Tracker 移动非 noexcept，使用 copy（输出: copy / copy）

    std::vector<TrackerNoexcept> v2;
    v2.reserve(2);
    v2.emplace_back();
    v2.emplace_back();
    v2.emplace_back();   // 触发扩容：使用 move（输出: move / move）
    return 0;
}

6.6 移动成员函数与 const 限制

#include <string>
#include <utility>

class Widget {
    std::string name_;
public:
    // const 成员函数内不能移动成员（this 是 const Widget*）
    std::string getName() const {
        // return std::move(name_);  // 警告：std::move 对 const T 实际上是 const T&&
        return name_;                 // 正确：返回拷贝
    }

    // 非 const 成员函数内可移动成员
    std::string stealName() {
        return std::move(name_);
    }
};

int main() {
    Widget w;
    std::string n1 = w.getName();     // 拷贝
    std::string n2 = w.stealName();   // 移动
    return 0;
}

注意：std::move 对 const T 对象是「失效」的——std::move 会推导为 const T&&，但 const T&& 不能绑定到 T&& 形参，重载解析退化为 const T&（拷贝）。

第 7 章 std::move 与 std::forward 的形式化语义

7.1 std::move 的实现与本质

std::move 的标准库实现（简化）：

template<typename T>
constexpr std::remove_reference_t<T>&& move(T&& t) noexcept {
    return static_cast<std::remove_reference_t<T>&&>(t);
}

关键点：

1. T&& 形参配合模板推导，使 move 能接受任意值类别的实参（forwarding reference 形式）；
2. remove_reference_t<T> 剥离引用修饰，得到裸类型；
3. static_cast<X&&> 将表达式转为 xvalue（按 [expr.type] 规则）。

std::move 是纯编译期操作，运行期零开销。

7.2 std::forward 的实现

std::forward 的标准库实现：

template<typename T>
constexpr T&& forward(std::remove_reference_t<T>& t) noexcept {
    return static_cast<T&&>(t);
}

template<typename T>
constexpr T&& forward(std::remove_reference_t<T>&& t) noexcept {
    static_assert(!std::is_lvalue_reference_v<T>, "Cannot forward an rvalue as lvalue.");
    return static_cast<T&&>(t);
}

两个重载：

• 第一个接受 lvalue，无 static_assert，可处理 T = U&（保持 lvalue）或 T = U（转为 rvalue）；
• 第二个接受 rvalue，static_assert 禁止将 rvalue 当作 lvalue 转发。

7.3 std::move 与 std::forward 的语义对比

#include <utility>
#include <iostream>

void target(int&)       { std::puts("lvalue"); }
void target(int&&)      { std::puts("rvalue"); }

template<typename T>
void forward_call(T&& x) {
    target(std::forward<T>(x));   // 按实参值类别转发
}

template<typename T>
void move_call(T& x) {
    target(std::move(x));          // 无条件转 rvalue
}

int main() {
    int a = 1;

    forward_call(a);               // 输出: lvalue（保留 a 的值类别）
    forward_call(std::move(a));    // 输出: rvalue
    forward_call(2);               // 输出: rvalue

    move_call(a);                  // 输出: rvalue（无论 a 原本是 lvalue）
    return 0;
}

形式化对比：

7.4 错误使用案例

#include <utility>
#include <vector>
#include <iostream>

// 错误 1：对 return 语句中的局部变量使用 std::move，阻碍 RVO/NRVO
std::vector<int> bad_return() {
    std::vector<int> v = {1, 2, 3};
    return std::move(v);           // 阻碍 NRVO！
}

std::vector<int> good_return() {
    std::vector<int> v = {1, 2, 3};
    return v;                       // NRVO 优先生先；退化为隐式 std::move
}

// 错误 2：对 const 对象使用 std::move
#include <string>
std::string bad_const(const std::string& s) {
    return std::move(s);            // 退化为拷贝（std::move 对 const T& 失效）
}

std::string good_const(const std::string& s) {
    return s;                       // 拷贝（明确意图）
}

// 错误 3：在 forwarding reference 之外使用 std::forward<T>
template<typename T>
void bad_forward(T x) {
    auto&& y = std::forward<T>(x);  // T 永远是 non-reference，等同 std::move
}

int main() {
    auto v1 = bad_return();         // 输出可能: move ctor 调用
    auto v2 = good_return();        // 输出: NRVO，无 move/copy ctor
    return 0;
}

7.5 标准库类型的移动行为

#include <vector>
#include <string>
#include <memory>
#include <utility>
#include <iostream>

int main() {
    // std::vector：内部 buffer 指针交换，O(1)
    std::vector<int> a = {1, 2, 3, 4, 5};
    std::vector<int> b = std::move(a);
    std::cout << "a.size=" << a.size() << "\n";  // 输出: a.size=0（标准未规定，但常见为 0）
    std::cout << "b.size=" << b.size() << "\n";  // 输出: b.size=5

    // std::string：SSO 优化下小字符串可能拷贝，大字符串 O(1) 移动
    std::string s1 = "very long string exceeding SSO threshold..........";
    std::string s2 = std::move(s1);
    std::cout << "s1='" << s1 << "'\n";           // 输出: s1=''（moved-from，未指定但常为空）
    std::cout << "s2.size=" << s2.size() << "\n"; // 输出: s2.size=49

    // std::unique_ptr：指针交换，源变 nullptr
    auto p1 = std::make_unique<int>(42);
    auto p2 = std::move(p1);
    std::cout << "p1=" << (p1 ? "valid" : "null") << "\n";  // 输出: p1=null
    std::cout << "*p2=" << *p2 << "\n";                      // 输出: *p2=42

    // std::shared_ptr：控制块原子操作，引用计数不变
    auto sp1 = std::make_shared<int>(42);
    auto sp2 = std::move(sp1);
    std::cout << "sp1=" << (sp1 ? "valid" : "null") << "\n";  // 输出: sp1=null
    std::cout << "*sp2=" << *sp2 << "\n";                      // 输出: *sp2=42
    std::cout << "use_count=" << sp2.use_count() << "\n";      // 输出: use_count=1
    return 0;
}

第 8 章 完美转发

8.1 完美转发问题陈述

考虑一个泛型工厂函数 make<T>，希望将参数包原封不动地转发给 T 的构造函数：

#include <memory>
#include <string>

// C++14 标准库的 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)...));
}

// 使用
int main() {
    auto p1 = std::make_unique<std::string>(10, 'a');          // 调用 string(size_t, char)
    auto p2 = std::make_unique<std::string>("hello");          // 调用 string(const char*)
    auto p3 = std::make_unique<std::string>(*p1);              // 调用 string(const string&)

    std::string s = "world";
    auto p4 = std::make_unique<std::string>(std::move(s));     // 调用 string(string&&)
    return 0;
}

「完美转发」的目标：

1. 值类别保留：实参为 lvalue 则转发后为 lvalue；实参为 rvalue 则转发后为 rvalue。
2. const 性保留：实参为 const T& 则转发后为 const T&。
3. 零额外开销：不引入临时对象、不引入额外拷贝/移动。

8.2 不完美转发的失败案例

#include <iostream>
#include <utility>

void target(int&)  { std::puts("lvalue"); }
void target(int&&) { std::puts("rvalue"); }

// 失败 1：按值传递，实参值类别丢失
template<typename T>
void bad_value(T x) {
    target(x);                    // 永远 lvalue（函数形参是 lvalue）
}

// 失败 2：按 const 引用传递，无法区分 lvalue/rvalue
template<typename T>
void bad_const_ref(const T& x) {
    target(x);                    // 永远 lvalue
}

// 失败 3：按右值引用传递，无法接受 lvalue 实参
template<typename T>
void bad_rvalue_ref(T&& x) {      // 在非模板上下文，T&& 是 rvalue reference
    target(std::forward<T>(x));   // 仅当 T 为 forwarding reference 才正确
}

// 注：bad_rvalue_ref 中 T&& 在非模板推导上下文是右值引用，无法接受 lvalue

int main() {
    int x = 1;
    bad_value(x);                 // 输出: lvalue（期望）
    bad_value(std::move(x));      // 输出: lvalue（失败：实参是 rvalue 但被退化为 lvalue）
    return 0;
}

8.3 完美转发的形式化推导

完美转发的关键步骤：

步骤 1：使用 T&&（forwarding reference）形式接收实参：

template<typename T>
void perfect(T&& x);

步骤 2：按 [temp.deduct.call] 的特殊推导规则：

• 实参为 lvalue of U → T = U&，经折叠 T&& = U& && = U&
• 实参为 rvalue of U → T = U，T&& = U&&（无折叠）

步骤 3：在函数体内调用 std::forward<T>(x)：

• T = U& 时：std::forward<U&>(x) 返回 static_cast<U&>(x)，即 lvalue
• T = U 时：std::forward<U>(x) 返回 static_cast<U&&>(x)，即 xvalue

值类别完整保留。

8.4 完美转发的可变参数版本

#include <utility>
#include <memory>
#include <vector>
#include <string>

// 通用工厂函数
template<typename T, typename... Args>
T make(Args&&... args) {
    return T(std::forward<Args>(args)...);
}

// 通用 emplace 操作
template<typename Container, typename... Args>
auto emplace_one(Container& c, Args&&... args) -> decltype(c.emplace_back(std::forward<Args>(args)...)) {
    return c.emplace_back(std::forward<Args>(args)...);
}

int main() {
    auto s = make<std::string>(10, 'x');          // 调用 string(size_t, char)

    std::vector<std::string> v;
    emplace_one(v, "hello");                       // emplace_back(const char*)
    emplace_one(v, 10, 'y');                       // emplace_back(size_t, char)

    std::string existing = "world";
    emplace_one(v, std::move(existing));           // emplace_back(string&&)
    return 0;
}

8.5 完美转发的限制：丢失 const 性

完美转发不完美之处：

#include <utility>
#include <iostream>

void target(int&)        { std::puts("lvalue"); }
void target(const int&)  { std::puts("const lvalue"); }
void target(int&&)       { std::puts("rvalue"); }

template<typename T>
void forward_call(T&& x) {
    target(std::forward<T>(x));
}

int main() {
    int a = 1;
    const int b = 2;

    forward_call(a);                  // 输出: lvalue
    forward_call(b);                  // 输出: const lvalue（T = const int&，正确保留 const）
    forward_call(std::move(a));       // 输出: rvalue
    forward_call(std::move(b));       // 输出: const lvalue（const rvalue 退化为 const lvalue 引用）
    return 0;
}

完美转发实际保留的是「实参的 cv 限定 + 值类别」。对 const T 实参，std::move(const T) 是 const T&&，但 const T&& 不能绑定 T&&，重载解析退化为 const T&。这是 std::move 对 const 对象「失效」的机制。

8.6 完美转发与继承构造

#include <utility>
#include <string>

class Base {
public:
    Base(int x) {}
    Base(const std::string& s) {}
    Base(std::string&& s) {}
};

class Derived : public Base {
public:
    // 完美转发继承构造（C++11 using 声明 + 可变参数模板）
    template<typename... Args>
    explicit Derived(Args&&... args) : Base(std::forward<Args>(args)...) {}
};

int main() {
    Derived d1(42);
    Derived d2("hello");
    Derived d3(std::string("world"));
    return 0;
}

注意：C++11 的 using Base::Base; 已能继承构造函数，本例仅为演示完美转发的应用场景。

8.7 std::forward 与 std::move 的状态机

stateDiagram-v2
    [*] --> LvalueArg: 实参为 lvalue
    [*] --> RvalueArg: 实参为 rvalue

    LvalueArg --> DeduceTRef: T = U&
    RvalueArg --> DeduceT: T = U

    DeduceTRef --> ForwardTRef: forward<U&>(x)
    DeduceT --> ForwardT: forward<U>(x)

    ForwardTRef --> OutputLvalue: static_cast<U&>(x)
    ForwardT --> OutputXvalue: static_cast<U&&>(x)

    OutputLvalue --> [*]
    OutputXvalue --> [*]

8.8 完美转发与 lambda

#include <utility>
#include <vector>
#include <functional>

// 完美转发 lambda：捕获参数包并延迟转发
template<typename F, typename... Args>
auto make_deferred(F&& f, Args&&... args) {
    // 注意：C++20 起允许在 lambda 初始化捕获中使用参数包展开
    return [f = std::forward<F>(f),
            ... captured_args = std::forward<Args>(args)]() mutable {
        return f(captured_args...);
    };
}

int main() {
    auto task = make_deferred([](int a, int b) { return a + b; }, 3, 4);
    return task();   // 返回: 7
}

第 9 章 引用折叠规则

9.1 引用折叠的四个组合

C++ 不允许「引用的引用」直接出现，但在模板推导、typedef、decltype 等上下文中可能间接产生。引用折叠规则：

口诀：「左值引用传染，仅当两者均为右值引用才保持右值引用」。

9.2 引用折叠触发的场景

#include <type_traits>

// 场景 1：模板参数推导
template<typename T>
void f(T&& x) {}

// 调用 f<int&>(a) 时 T = int&，T&& = int& && = int&
// 调用 f<int>(a) 时 T = int，T&& = int&&

// 场景 2：typedef / using 别名
using LRefInt = int&;
using RRefInt = int&&;
static_assert(std::is_same_v<LRefInt, int&>);
static_assert(std::is_same_v<LRefInt&&, int&>);     // 折叠
static_assert(std::is_same_v<RRefInt&, int&>);      // 折叠
static_assert(std::is_same_v<RRefInt&&, int&&>);    // 不折叠

// 场景 3：decltype 嵌套
int x = 0;
static_assert(std::is_same_v<decltype((x)), int&>);     // decltype((x)) 是 int&
// decltype(int& &&) 会折叠为 int&

int main() { return 0; }

9.3 引用折叠与 forwarding reference

template<typename T> void f(T&& x) 中 T&& 是「forwarding reference」（转发引用，由 Scott Meyers 在《Effective Modern C++》（2015）中提出的术语，指「函数模板参数中形式为 T&& 的引用」，与「右值引用」区分；标准正式名称为「forwarding reference」（N4277, 2015）），仅在以下条件同时满足时成立：

1. 形式为 T&&（其中 T 是模板参数）；
2. T 是当前函数模板的推导参数；
3. 没有其他限定（如 const T&& 不是 forwarding reference）。

#include <vector>

template<typename T>
void ok1(T&& x);                   // forwarding reference

template<typename T>
void ok2(std::vector<T>&& x);      // 不是：T 不是直接 T&&

template<typename T>
class C {
    template<typename U>
    void ok3(U&& x);               // forwarding reference

    void not_ok(T&& x);            // 不是：T 是类模板参数，非函数模板推导
};

template<typename T>
void not_ok4(const T&& x);         // 不是：有 const 限定

template<typename T>
void not_ok5(T& x);                // 不是：形式不是 T&&

9.4 forwarding reference 与 rvalue reference 的区分

#include <utility>
#include <iostream>
#include <vector>

// 形式相似但语义完全不同
template<typename T>
void forwarding_ref(T&& x) {                // forwarding reference
    std::cout << "forwarding: " << __PRETTY_FUNCTION__ << "\n";
}

void rvalue_ref(int&& x) {                  // rvalue reference
    std::cout << "rvalue: " << __PRETTY_FUNCTION__ << "\n";
}

template<typename T>
struct Wrapper {
    void member_rvalue(T&& x) {             // rvalue reference（T 已固定）
        std::cout << "member: " << __PRETTY_FUNCTION__ << "\n";
    }
};

int main() {
    int a = 1;
    forwarding_ref(a);              // 合法：T = int&，折叠后为 int&
    forwarding_ref(std::move(a));   // 合法：T = int

    // rvalue_ref(a);               // 错误：rvalue reference 不能绑定 lvalue
    rvalue_ref(std::move(a));       // 合法
    rvalue_ref(2);                  // 合法

    Wrapper<int> w;
    // w.member_rvalue(a);          // 错误：T = int 已固定，T&& 是 rvalue reference
    w.member_rvalue(std::move(a));  // 合法
    return 0;
}

9.5 引用折叠的实际机制

#include <utility>
#include <type_traits>

// 自制 std::move（展示引用折叠）
template<typename T>
constexpr std::remove_reference_t<T>&& my_move(T&& x) noexcept {
    return static_cast<std::remove_reference_t<T>&&>(x);
}

// 自制 std::forward
template<typename T>
constexpr T&& my_forward(std::remove_reference_t<T>& x) noexcept {
    return static_cast<T&&>(x);
}

int main() {
    int a = 1;

    // my_move(a) 时：T = int&（forwarding reference 推导）
    // remove_reference_t<int&> = int
    // 返回类型 = int&&
    // static_cast<int&&>(x) 将 lvalue 转 xvalue
    auto&& r1 = my_move(a);
    static_assert(std::is_same_v<decltype(r1), int&&>);

    // my_forward<int&>(a) 时：T = int&
    // remove_reference_t<int&> = int
    // 函数形参类型 = int&
    // 返回类型 = int& &&（折叠为 int&）
    // static_cast<int&>(x) 保持 lvalue
    auto&& r2 = my_forward<int&>(a);
    static_assert(std::is_same_v<decltype(r2), int&>);

    return 0;
}

第 10 章 T&& 模板推导规则

10.1 推导规则总览

T&& 在不同上下文有不同推导规则：

10.2 auto 与 auto&& 的推导

#include <type_traits>
#include <utility>

int g = 0;

int main() {
    auto a = g;                              // auto = int
    auto& b = g;                             // auto = int，b 类型为 int&
    const auto& c = g;                       // auto = int，c 类型为 const int&
    auto&& d = g;                            // auto = int&（lvalue 实参），d 类型为 int& && = int&
    auto&& e = std::move(g);                 // auto = int（rvalue 实参），e 类型为 int&&
    auto&& f = 42;                           // auto = int（prvalue 实参），f 类型为 int&&

    static_assert(std::is_same_v<decltype(d), int&>);
    static_assert(std::is_same_v<decltype(e), int&&>);
    static_assert(std::is_same_v<decltype(f), int&&>);
    return 0;
}

10.3 decltype 推导规则

decltype 与 auto 推导规则不同，特别在处理引用与值类别上：

#include <type_traits>
#include <utility>

int g = 0;

int& lref() { return g; }
int prval() { return g; }
int&& rref() { return std::move(g); }

int main() {
    // decltype(variable) 退化为变量的声明类型
    int x = 0;
    static_assert(std::is_same_v<decltype(x), int>);           // 变量名 → 声明类型
    int& rx = x;
    static_assert(std::is_same_v<decltype(rx), int&>);

    // decltype((expression)) 保留值类别
    static_assert(std::is_same_v<decltype((x)), int&>);        // 加括号 → 表达式 → lvalue
    static_assert(std::is_same_v<decltype((g)), int&>);        // 全局变量 lvalue

    // decltype(function_call) 按函数返回类型
    static_assert(std::is_same_v<decltype(lref()), int&>);     // 返回 int&
    static_assert(std::is_same_v<decltype(prval()), int>);     // 返回 int（prvalue）
    static_assert(std::is_same_v<decltype(rref()), int&&>);    // 返回 int&&（xvalue）

    return 0;
}

decltype((x)) 与 decltype(x) 的区别是常见面试考点：前者是表达式，保留值类别（lvalue → int&）；后者是变量名，退化为声明类型（int）。

10.4 推导失败案例

#include <vector>
#include <utility>

// 失败 1： initializer_list 无法直接推导
template<typename T>
void take_init_list(std::initializer_list<T> il) {}

void use1() {
    // take_init_list({1, 2, 3});     // 错误：模板参数 T 无法从 {1,2,3} 推导
    take_init_list<int>({1, 2, 3});   // 显式指定 OK
}

// 失败 2：转发引用与函数重载的歧义
template<typename T>
void f(T&& x);                         // forwarding reference（最贪婪）

void f(int x);                         // 具体重载

void use2() {
    f(42);                             // 调用 f(int)：具体重载优先
    int a = 1;
    f(a);                              // 调用 f(T&&)，T = int&（forwarding reference 优先于 f(int)？）
}

// 失败 3：完美转发与 const 重载的冲突
template<typename T>
void g(T&& x);                         // 转发引用，接受 const T& 也可
void g(const std::string& x);          // 专门处理 const std::string&

void use3() {
    const std::string s = "hello";
    g(s);                              // 歧义：两者均可接受，模板更精确匹配（T = const string&）
}

int main() { return 0; }

10.5 std::common_type 与条件推导

#include <type_traits>
#include <utility>

// 条件返回类型：根据 T 的值类别返回不同类型
template<typename T>
auto get_value(T&& x) -> std::conditional_t<
    std::is_lvalue_reference_v<T>,
    std::remove_reference_t<T>&,
    std::remove_reference_t<T>
> {
    return std::forward<T>(x);
}

// C++14 decltype(auto) 自动保留值类别
template<typename T>
decltype(auto) forward_auto(T&& x) {
    return std::forward<T>(x);
}

int main() {
    int a = 42;
    auto& b = get_value(a);              // T = int&，返回 int&
    auto c = get_value(std::move(a));    // T = int，返回 int（值）

    int x = 1;
    decltype(auto) d = forward_auto(x);              // d 类型为 int&
    decltype(auto) e = forward_auto(std::move(x));   // e 类型为 int&&
    return 0;
}

第 11 章 对比分析

11.1 与复制省略（copy elision）的对比

#include <iostream>
#include <string>

struct Tracer {
    Tracer() { std::puts("default"); }
    Tracer(const Tracer&) { std::puts("copy"); }
    Tracer(Tracer&&) { std::puts("move"); }
    ~Tracer() { std::puts("dtor"); }
};

// (1) C++17 强制省略：prvalue 初始化，无临时对象
Tracer make_prvalue() { return Tracer(); }

// (2) NRVO：编译器可选优化，失败时退化为隐式 std::move
Tracer make_nrvo() {
    Tracer t;
    return t;
}

// (3) std::move：显式禁用 NRVO，强制调用移动构造
Tracer make_move() {
    Tracer t;
    return std::move(t);     // 反模式！阻碍 NRVO
}

int main() {
    Tracer a = make_prvalue();   // C++17: 输出 default / dtor
    Tracer b = make_nrvo();      // NRVO: 输出 default / dtor；否则: default / move / dtor / dtor
    Tracer c = make_move();      // 输出 default / move / dtor / dtor
    return 0;
}

对比表：

11.2 移动语义与智能指针协同

#include <memory>
#include <vector>
#include <utility>

int main() {
    // unique_ptr 是 move-only 类型，必须通过移动语义转移所有权
    auto p1 = std::make_unique<int>(42);
    // auto p2 = p1;                       // 错误：拷贝构造被删除
    auto p2 = std::move(p1);                // 正确：移动构造

    // 容器持有 unique_ptr
    std::vector<std::unique_ptr<int>> v;
    v.push_back(std::make_unique<int>(1));
    v.push_back(std::make_unique<int>(2));

    // 扩容时通过移动构造转移所有权
    std::vector<std::unique_ptr<int>> w = std::move(v);

    // shared_ptr 兼具拷贝与移动
    auto sp1 = std::make_shared<int>(42);
    auto sp2 = sp1;                         // 拷贝：引用计数 +1
    auto sp3 = std::move(sp1);              // 移动：引用计数不变，sp1 变 null

    return 0;
}

11.3 与 Rust 所有权转移的对比

// Rust：move 是位拷贝式，源对象在类型系统中失效
fn rust_move() {
    let s1 = String::from("hello");
    let s2 = s1;                          // move：s1 失效
    // println!("{}", s1);                // 编译错误：borrow of moved value
}

// C++：move 是运行期行为，源对象进入「valid but unspecified」状态
#include <string>
#include <utility>

void cpp_move() {
    std::string s1 = "hello";
    std::string s2 = std::move(s1);       // move：s1 仍存活，但状态未指定
    // s1.empty();                        // 合法但返回未指定值
    s1 = "reset";                          // 合法：可重新赋值
}

对比表：

11.4 与 C# / Java 值类型对比

// C#：struct 是值类型，赋值即深拷贝
struct Point {
    public int X, Y;
}

void CSharp() {
    Point a = new Point { X = 1, Y = 2 };
    Point b = a;                       // 深拷贝
    b.X = 100;
    // a.X 仍为 1
}

// Java：所有对象为引用类型，赋值即引用拷贝
class JPoint { int x, y; }

void Java() {
    JPoint a = new JPoint();
    a.x = 1;
    JPoint b = a;                      // 引用拷贝，a 与 b 指向同一对象
    b.x = 100;
    // a.x 也变为 100
}

C++ 的移动语义填补了「值语义深拷贝」与「引用语义共享」之间的设计空间，提供「独占所有权 + 零开销转移」的中间路径。

11.5 std::vector::push_back 三重载分析

#include <vector>
#include <string>
#include <utility>

int main() {
    std::vector<std::string> v;

    // (1) push_back(const T&)：接受 lvalue
    std::string s1 = "hello";
    v.push_back(s1);                    // 调用 const string& 重载，拷贝构造

    // (2) push_back(T&&)：接受 rvalue
    v.push_back(std::move(s1));         // 调用 string&& 重载，移动构造
    v.push_back("world");               // 字符串字面量 → string 临时对象 → 移动

    // (3) emplace_back(Args&&...)：完美转发
    v.emplace_back(10, 'a');            // 直接 emplace_back(size_t, char) 构造

    return 0;
}

性能对比（对小字符串 SSO 内）：

• push_back(const T&)：1 次拷贝构造
• push_back(T&&)：1 次移动构造
• emplace_back(Args...)：1 次直接构造（无中间临时对象）

对大字符串或资源拥有型对象：emplace_back 优势显著。

第 12 章 工程实践

12.1 默认编写 noexcept 移动构造

#include <vector>
#include <string>
#include <utility>

class Good {
    std::string name_;
    std::vector<int> data_;
public:
    Good() = default;
    Good(const Good&) = default;

    // 关键：noexcept 让 vector::resize 选择移动而非拷贝
    Good(Good&&) noexcept = default;
    Good& operator=(Good&&) noexcept = default;
    ~Good() = default;
};

int main() {
    std::vector<Good> v;
    v.reserve(2);
    v.emplace_back();
    v.emplace_back();
    v.emplace_back();   // 扩容：因移动 noexcept，使用移动构造
    return 0;
}

12.2 五法则与零法则

#include <memory>
#include <string>

// 五法则：自定义析构 → 必须自定义拷贝/移动构造/赋值
class Five {
    int* data_;
public:
    Five() : data_(new int(0)) {}
    ~Five() { delete data_; }
    Five(const Five& o) : data_(new int(*o.data_)) {}
    Five(Five&& o) noexcept : data_(o.data_) { o.data_ = nullptr; }
    Five& operator=(const Five& o) {
        if (this != &o) { delete data_; data_ = new int(*o.data_); }
        return *this;
    }
    Five& operator=(Five&& o) noexcept {
        if (this != &o) { delete data_; data_ = o.data_; o.data_ = nullptr; }
        return *this;
    }
};

// 零法则：使用 RAII 成员让编译器自动生成默认操作
class Zero {
    std::unique_ptr<int> data_;       // RAII 成员
    std::string name_;
public:
    Zero() = default;                 // 默认构造
    // 不需要自定义析构/拷贝/移动：编译器生成正确版本
    // unique_ptr 的 move-only 性质使 Zero 也成为 move-only
};

int main() {
    Zero a;
    // Zero b = a;                    // 错误：unique_ptr 不可拷贝
    Zero c = std::move(a);            // 正确：移动
    return 0;
}

12.3 工厂函数与完美转发

#include <memory>
#include <utility>
#include <string>

// 通用工厂：返回 unique_ptr，完美转发参数
template<typename T, typename... Args>
std::unique_ptr<T> make(Args&&... args) {
    return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
}

// 工厂返回 shared_ptr
template<typename T, typename... Args>
std::shared_ptr<T> make_shared(Args&&... args) {
    return std::shared_ptr<T>(new T(std::forward<Args>(args)...));
    // 注意：标准库 std::make_shared 性能更优（单次分配）
}

int main() {
    auto p = make<std::string>(10, 'x');
    auto sp = make_shared<std::string>("hello");
    return 0;
}

12.4 容器与移动语义

#include <vector>
#include <string>
#include <utility>

int main() {
    std::vector<std::string> v;

    // 推荐：emplace_back 完美转发，避免临时对象
    v.emplace_back("hello");

    // 推荐：对 lvalue 显式 std::move 转移所有权
    std::string s = "world";
    v.push_back(std::move(s));           // 移动后 s 进入 moved-from 状态

    // 推荐：批量插入时使用移动迭代器
    std::vector<std::string> src = {"a", "b", "c"};
    std::vector<std::string> dst;
    dst.reserve(src.size());
    std::move(src.begin(), src.end(), std::back_inserter(dst));   // C++11

    // C++20 ranges：更清晰的移动视图
    // dst = src | std::views::transform([](auto& s) { return std::move(s); });

    return 0;
}

12.5 Pimpl 与移动语义

#include <memory>
#include <string>

// Pimpl：编译防火墙 + 移动语义（unique_ptr 是 move-only）
class Widget {
public:
    Widget();
    ~Widget();                            // 必须在 .cpp 中定义（不完全类型）
    Widget(Widget&&) noexcept;            // 同上
    Widget& operator=(Widget&&) noexcept; // 同上
    Widget(const Widget&);
    Widget& operator=(const Widget&);

    void do_something();
private:
    struct Impl;
    std::unique_ptr<Impl> impl_;
};

// 实现文件 .cpp:
// Widget::Widget() : impl_(std::make_unique<Impl>()) {}
// Widget::~Widget() = default;
// Widget::Widget(Widget&&) noexcept = default;
// ...

int main() {
    Widget w1;
    Widget w2 = std::move(w1);            // 移动所有权
    return 0;
}

12.6 ABI 稳定性与移动语义

#include <memory>

// 反模式：跨 ABI 边界暴露 std::unique_ptr
// 问题描述：std::unique_ptr 的 sizeof 与布局可能因标准库实现不同而不同
// class DLL_API Bad {
// public:
//     std::unique_ptr<Impl> impl_;  // ABI 不稳定
// };

// 推荐：跨 ABI 边界使用裸指针 + 自定义释放函数
class DLL_API Good {
public:
    Good();
    ~Good();
    Good(Good&&) noexcept;
    Good& operator=(Good&&) noexcept;
private:
    struct Impl;
    Impl* impl_;                          // 裸指针，ABI 稳定
};

// 内部使用 unique_ptr，对外暴露裸指针
// Good::Good() : impl_(new Impl()) {}
// Good::~Good() { delete impl_; }

12.7 异常安全与移动语义

#include <vector>
#include <string>
#include <utility>

// 强异常安全保证：使用 copy-and-swap
class StrongExceptionSafe {
    std::vector<std::string> data_;
public:
    StrongExceptionSafe(const StrongExceptionSafe& o) : data_(o.data_) {}

    // 统一赋值：按值传入（编译器选择拷贝/移动），swap 异常安全
    StrongExceptionSafe& operator=(StrongExceptionSafe other) noexcept {
        data_.swap(other.data_);          // swap 是 noexcept
        return *this;
    }

    // 添加元素：rollback on exception
    void add(const std::string& s) {
        auto copy = data_;                // 拷贝当前状态
        copy.push_back(s);                // 修改副本
        data_.swap(copy);                 // 原子提交
    }
};

int main() {
    StrongExceptionSafe a;
    a.add("hello");
    StrongExceptionSafe b;
    b = a;                                // 拷贝
    b = std::move(a);                     // 移动
    return 0;
}

12.8 多线程与移动语义

#include <thread>
#include <memory>
#include <utility>
#include <vector>

// 移动语义在多线程中传递所有权
void worker(std::unique_ptr<int> p, std::vector<int> v) {
    // p 与 v 的所有权进入工作线程
}

int main() {
    auto p = std::make_unique<int>(42);
    std::vector<int> v = {1, 2, 3};

    // 移动到线程：避免拷贝
    std::thread t(worker, std::move(p), std::move(v));
    t.join();

    // 移动 thread 本身
    std::thread t2([]{ /* ... */ });
    std::thread t3 = std::move(t2);       // thread 是 move-only
    t3.join();
    return 0;
}

12.9 自定义类型的移动语义最佳实践

#include <utility>
#include <vector>
#include <cstring>

class MyString {
    char* data_;
    size_t size_;
public:
    MyString() : data_(nullptr), size_(0) {}

    explicit MyString(const char* s) : size_(std::strlen(s)) {
        data_ = new char[size_ + 1];
        std::strcpy(data_, s);
    }

    ~MyString() { delete[] data_; }

    // 拷贝构造：深拷贝
    MyString(const MyString& o) : size_(o.size_) {
        data_ = new char[size_ + 1];
        std::strcpy(data_, o.data_);
    }

    // 移动构造：noexcept + 资源掠夺 + 源置空
    MyString(MyString&& o) noexcept
        : data_(o.data_), size_(o.size_) {
        o.data_ = nullptr;
        o.size_ = 0;
    }

    // copy-and-swap 统一赋值
    MyString& operator=(MyString o) noexcept {
        swap(o);
        return *this;
    }

    // swap：noexcept + ADL 友好
    void swap(MyString& o) noexcept {
        std::swap(data_, o.data_);
        std::swap(size_, o.size_);
    }

    // 友元 swap：支持 using std::swap; swap(a, b);
    friend void swap(MyString& a, MyString& b) noexcept {
        a.swap(b);
    }

    const char* c_str() const { return data_ ? data_ : ""; }
    size_t size() const { return size_; }
};

int main() {
    MyString a("hello");
    MyString b = std::move(a);
    using std::swap;
    swap(a, b);
    return 0;
}