1
std::vector<std::string> buildNames() {
2
    std::vector<std::string> names;
3
    names.push_back("Alice");
4
    names.push_back("Bob");
5
    return names;  // C++11 之前：拷贝整个 vector + 所有 string → 巨大开销
6
                   // C++11 之后：移动 vector（偷指针）→ O(1)
7
}
8

9
// 更极端的例子：游戏中的 Mesh 数据
10
struct Mesh {
11
    std::vector<float> vertices;      // 可能有百万个顶点
12
    std::vector<uint32_t> indices;    // 百万个索引
13
    std::vector<float> normals;       // 百万个法线
14
    // 拷贝 = 复制 3 个百万级数组 → 几十毫秒
15
    // 移动 = 偷 3 个指针 → 几纳秒
16
};

1
int x = 42;
2

3
// 左值引用：绑定到左值
4
int& lref = x;          // ✅
5
// int& lref2 = 42;     // ❌ 不能绑定到右值
6

7
// const 左值引用：可以绑定到**任何东西**（万能？）
8
const int& clref = x;    // ✅ 绑定左值
9
const int& clref2 = 42;  // ✅ 绑定右值（延长临时对象生命周期）
10

11
// 右值引用：只绑定到右值
12
int&& rref = 42;          // ✅ 绑定纯右值
13
int&& rref2 = std::move(x); // ✅ 绑定将亡值
14
// int&& rref3 = x;       // ❌ 不能绑定到左值
15

16
// ⚠️ 关键：rref 本身是一个左值！（因为它有名字）
17
// int&& rref4 = rref;    // ❌ rref 是左值，不能绑定到 &&
18
int&& rref4 = std::move(rref); // ✅ 必须再 move 一次

1
class String {
2
    char* _data;
3
    size_t _size;
4

5
public:
6
    // 构造
7
    String(const char* str = "") {
8
        _size = std::strlen(str);
9
        _data = new char[_size + 1];
10
        std::memcpy(_data, str, _size + 1);
11
    }
12

13
    // 1. 析构
14
    ~String() {
15
        delete[] _data;
16
    }
17

18
    // 2. 拷贝构造：深拷贝
19
    String(const String& other) : _size(other._size) {
20
        _data = new char[_size + 1];
21
        std::memcpy(_data, other._data, _size + 1);
22
        std::cout << "拷贝构造（深拷贝 " << _size << " 字节）\n";
23
    }
24

25
    // 3. 拷贝赋值：深拷贝 + 释放旧数据
26
    String& operator=(const String& other) {
27
        if (this != &other) {
28
            delete[] _data;
29
            _size = other._size;
30
            _data = new char[_size + 1];
31
            std::memcpy(_data, other._data, _size + 1);
32
        }
33
        std::cout << "拷贝赋值\n";
34
        return *this;
35
    }
36

37
    // 4. 移动构造：偷资源 ✅
38
    String(String&& other) noexcept
39
        : _data(other._data), _size(other._size) {
40
        other._data = nullptr;   // 偷完后置空，防止 other 析构时 delete
41
        other._size = 0;
42
        std::cout << "移动构造（零拷贝！）\n";
43
    }
44

45
    // 5. 移动赋值：释放自己的 + 偷来源的
46
    String& operator=(String&& other) noexcept {
47
        if (this != &other) {
48
            delete[] _data;          // 释放自己的旧数据
49
            _data = other._data;     // 偷
50
            _size = other._size;
51
            other._data = nullptr;   // 置空来源
52
            other._size = 0;
53
        }
54
        std::cout << "移动赋值（零拷贝！）\n";
55
        return *this;
56
    }
57

58
    size_t size() const { return _size; }
59
    const char* c_str() const { return _data ? _data : ""; }
60
};

1
// 为什么移动构造必须标记 noexcept？
2

3
std::vector<String> v;
4
v.push_back(String("hello"));
5
v.push_back(String("world"));
6
// vector 扩容时，需要把旧元素搬到新内存
7

8
// 如果移动构造是 noexcept：
9
//   vector 用 移动 搬元素 → O(1) 每个元素 ✅
10

11
// 如果移动构造没有 noexcept：
12
//   vector 用 拷贝 搬元素 → O(n) 每个元素 😱
13
//   原因：如果移动到一半抛异常，已经移走的元素回不来了（源对象已被修改）
14
//         而拷贝不会修改源对象，可以安全回滚
15

16
// vector 内部的决策逻辑：
17
// std::move_if_noexcept(element)
18
// = 如果移动构造是 noexcept → std::move(element)
19
// = 如果移动构造可能抛异常 → element（拷贝）

1
// std::move 的实现（简化版）：
2
template <typename T>
3
constexpr std::remove_reference_t<T>&& move(T&& t) noexcept {
4
    return static_cast<std::remove_reference_t<T>&&>(t);
5
}
6

7
// 它做的事情 100% 等价于：
8
static_cast<String&&>(s);  // 把 s 的值类别从左值"标记"为右值
9

10
// 真正的移动发生在哪里？
11
// 在移动构造函数 / 移动赋值运算符中！
12
String a = "hello";
13
String b = std::move(a);
14
//          ↑ 这只是把 a 变成右值引用
15
//                    ↑ 这里调用了 String(String&&)，真正的资源转移在这里

1
// ⚠️ move 后的对象处于 "valid but unspecified" 状态
2
String s = "hello";
3
String t = std::move(s);
4

5
// s 现在可以：
6
s.size();           // ✅ 合法（可能返回 0）
7
s = "new value";    // ✅ 可以重新赋值
8
// 但不能假设 s 的具体内容
9
// std::cout << s.c_str(); // ⚠️ 可能是 ""，也可能是别的
10

11
// ⚠️ 对 const 对象 move 无效！
12
const String cs = "hello";
13
String u = std::move(cs);  // 调用的是拷贝构造！不是移动构造！
14
// 因为 std::move(cs) 返回 const String&&
15
// const String&& 不能匹配 String(String&&)，但能匹配 String(const String&)

1
// === 题目 1 ===
2
std::string s = "hello";
3
std::string t = std::move(s);
4
// 答：✅ 移动了。s 变成 valid but unspecified 状态。
5

6
// === 题目 2 ===
7
const std::string cs = "hello";
8
std::string t2 = std::move(cs);
9
// 答：❌ 没移动！std::move(cs) 返回 const string&&
10
// 不匹配 string(string&&)，匹配 string(const string&) → 拷贝
11

12
// === 题目 3 ===
13
std::string foo() {
14
    std::string s = "hello";
15
    return s;  // 这里是移动还是拷贝？
16
}
17
// 答：都不是。NRVO 直接省略了拷贝/移动。
18
// 如果 NRVO 失效，则 implicit move（C++11）。
19

20
// === 题目 4 ===
21
void bar(std::string&& s) {
22
    std::string local = s;  // 这里是移动还是拷贝？
23
}
24
// 答：拷贝！s 虽然类型是 string&&，但它有名字，是左值！
25
// 要移动需要：std::string local = std::move(s);
26

27
// === 题目 5 ===
28
template <typename T>
29
void baz(T&& arg) {
30
    process(arg);                    // 总是调用 process(T&)，因为 arg 是左值
31
    process(std::forward<T>(arg));   // 正确转发：左值→左值，右值→右值
32
    process(std::move(arg));         // 总是调用 process(T&&)，强制右值
33
}

1
class Mesh {
2
    std::vector<float> _vertices;
3
    std::vector<uint32_t> _indices;
4
    std::vector<float> _normals;
5
    std::string _name;
6

7
public:
8
    Mesh(std::string name, std::vector<float> verts,
9
         std::vector<uint32_t> indices, std::vector<float> normals)
10
        : _name(std::move(name)),           // 移动
11
          _vertices(std::move(verts)),       // 移动
12
          _indices(std::move(indices)),      // 移动
13
          _normals(std::move(normals)) {}    // 移动
14
    // 参数按值传递 → 调用者可以选择拷贝或移动
15
    // 函数内部总是移动（从参数偷）
16

17
    // 移动构造：自动生成（Rule of Zero）
18
    // 因为所有成员都可移动
19
};
20

21
// 使用：
22
std::vector<float> verts(1000000);   // 百万顶点
23
std::vector<uint32_t> indices(500000);
24
std::vector<float> normals(1000000);
25

26
// 方式 1：移动进去（零拷贝）
27
Mesh m1("Hero", std::move(verts), std::move(indices), std::move(normals));
28
// verts, indices, normals 现在是空的
29

30
// 方式 2：直接构造（RVO）
31
auto m2 = LoadMeshFromFile("hero.obj");
32
// LoadMeshFromFile 内部构造 Mesh → RVO 直接在 m2 位置构造，零拷贝零移动

1
class Texture {
2
    std::vector<uint8_t> _pixels;
3
    int _width, _height;
4

5
public:
6
    Texture(int w, int h, std::vector<uint8_t> pixels)
7
        : _width(w), _height(h), _pixels(std::move(pixels)) {}
8
};
9

10
// 返回大对象——RVO 保证零开销
11
Texture LoadTexture(const std::string& path) {
12
    int w, h;
13
    auto pixels = ReadFileBytes(path);  // 可能几 MB
14
    // ... 解码 ...
15
    return Texture(w, h, std::move(pixels));  // RVO：直接在调用者位置构造
16
}
17

18
auto tex = LoadTexture("hero.png");  // 无拷贝、无移动，直接构造 ✅

1
struct Particle {
2
    float x, y, z;
3
    float vx, vy, vz;
4
    float lifetime;
5

6
    Particle(float px, float py, float pz,
7
             float pvx, float pvy, float pvz, float lt)
8
        : x(px), y(py), z(pz), vx(pvx), vy(pvy), vz(pvz), lifetime(lt) {}
9
};
10

11
std::vector<Particle> particles;
12
particles.reserve(10000);  // 预分配避免扩容
13

14
// ❌ push_back：先构造临时 Particle，再移动到 vector 中
15
particles.push_back(Particle(1.0f, 2.0f, 3.0f, 0.1f, 0.2f, 0.f, 5.0f));
16

17
// ✅ emplace_back：直接在 vector 内部原地构造（完美转发参数）
18
particles.emplace_back(1.0f, 2.0f, 3.0f, 0.1f, 0.2f, 0.f, 5.0f);
19
// 省掉了一次构造 + 一次移动

1
// C++11 之前的 swap：3 次拷贝
2
template <typename T>
3
void old_swap(T& a, T& b) {
4
    T tmp = a;       // 拷贝
5
    a = b;           // 拷贝
6
    b = tmp;         // 拷贝
7
}
8

9
// C++11 之后的 swap：3 次移动
10
template <typename T>
11
void new_swap(T& a, T& b) noexcept(noexcept(T(std::move(a)))) {
12
    T tmp = std::move(a);  // 移动
13
    a = std::move(b);      // 移动
14
    b = std::move(tmp);    // 移动
15
}
16

17
// 对于 Mesh 这样的大对象：
18
// 旧 swap：复制 3 次百万级数组 → 几十 ms
19
// 新 swap：交换 3 次指针 → 几 ns