24. 移动语义与完美转发：右值引用、std::move、std::forward、移动构造函数与智能指针

移动语义和完美转发，是C++11引入的两大“核武器”。

说实话，我刚接触那会儿也觉得头大。什么左值右值，什么引用折叠，听着就绕。但后来在项目里被拷贝性能坑过几次，才真正体会到这两个特性的价值。

这一章，咱们就把它们彻底讲透。

24.1 左值和右值：先搞清楚“值类别”

要理解移动语义，得先知道什么是左值，什么是右值。

简单粗暴地说：

• 左值：有名字、能取地址、生命周期长。比如变量名、数组名、返回左值引用的函数调用。
• 右值：没名字、不能取地址、临时存在。比如字面量、表达式求值结果、返回非引用的函数调用。

int a = 42;      // a 是左值，42 是右值
int b = a + 5;   // a 是左值，a+5 是右值
int* p = &a;     // 可以取 a 的地址
// int* q = &42; // 错误！不能取右值的地址

嗯，这里要注意：C++11之后，右值又细分为“纯右值”和“将亡值”。不过咱们先不钻牛角尖，你只要记住——右值就是“用完就扔”的临时对象。

24.2 右值引用：给临时对象一个“家”

右值引用用 && 表示。它专门绑定到右值上。

int&& rref = 42;   // 合法，42 是右值
int x = 10;
// int&& rref2 = x; // 错误！x 是左值

你可能会问：“这有什么用？”

用处大了。右值引用让我们能“劫持”临时对象的资源。比如一个临时字符串，本来马上要销毁了，我们可以把它的内部缓冲区直接“偷”过来，省掉一次深拷贝。

24.3 移动构造函数：从“复制”到“偷取”

有了右值引用，移动构造函数就顺理成章了。

移动构造函数的参数是 T&&，它做的事情很简单：把源对象的资源指针“偷”过来，然后把源对象置为“空壳”状态。

class MyString {
public:
    // 普通构造函数
    MyString(const char* str) {
        size_ = strlen(str);
        data_ = new char[size_ + 1];
        memcpy(data_, str, size_ + 1);
    }

    // 拷贝构造函数（深拷贝）
    MyString(const MyString& other) {
        size_ = other.size_;
        data_ = new char[size_ + 1];
        memcpy(data_, other.data_, size_ + 1);
        std::cout << "拷贝构造\n";
    }

    // 移动构造函数（偷资源）
    MyString(MyString&& other) noexcept
        : data_(other.data_), size_(other.size_) {
        other.data_ = nullptr;
        other.size_ = 0;
        std::cout << "移动构造\n";
    }

    ~MyString() { delete[] data_; }

private:
    char* data_ = nullptr;
    size_t size_ = 0;
};

我在项目中遇到过这样一个场景：一个函数返回一个巨大的 std::vector<std::string>，如果不走移动构造，每次返回都要拷贝整个容器，性能惨不忍睹。加上移动构造后，几乎零开销。

24.4 std::move：把左值“伪装”成右值

std::move 并不移动任何东西。它只是一个类型转换，把左值转换成右值引用。

MyString s1("Hello");
MyString s2 = std::move(s1);  // 调用移动构造函数
// 此时 s1 的内容已被“掏空”，不要再使用 s1 的数据

说白了，std::move 就是告诉编译器：“这个对象我不用了，你尽管偷它的资源吧。”

24.5 std::forward：完美转发的“开关”

完美转发要解决什么问题？

看个例子：

template<typename T>
void wrapper(T&& arg) {
    // 我想把 arg 原封不动地传给 foo
    foo(arg);  // 这样对吗？
}

问题在于：arg 本身是一个左值（它有名字），所以 foo(arg) 永远传的是左值。即使调用 wrapper 时传的是右值，到了 foo 那里也变成左值了。

这时候就需要 std::forward：

template<typename T>
void wrapper(T&& arg) {
    foo(std::forward<T>(arg));  // 完美转发！
}

std::forward 会根据模板参数 T 的类型决定：如果 T 是左值引用，就返回左值引用；如果 T 是右值引用，就返回右值引用。

这背后的原理是“引用折叠”规则：

• T& & → T&
• T& && → T&
• T&& & → T&
• T&& && → T&&

说白了，只有 T&& && 才会折叠成右值引用，其他情况都是左值引用。

24.6 移动语义与智能指针

智能指针和移动语义是天作之合。

std::unique_ptr 是独占所有权的智能指针，它没有拷贝构造函数，只有移动构造函数。这意味着你不能复制一个 unique_ptr，但可以移动它。

std::unique_ptr<int> p1 = std::make_unique<int>(42);
// std::unique_ptr<int> p2 = p1;  // 错误！不能拷贝
std::unique_ptr<int> p3 = std::move(p1);  // 正确！转移所有权
// 此时 p1 为空，p3 持有资源

我在项目中经常用这个特性来明确所有权转移。比如工厂函数返回 unique_ptr，调用方用 auto ptr = createObject(); 接收，语义非常清晰。

std::shared_ptr 也支持移动语义。移动一个 shared_ptr 比拷贝它更高效，因为移动只需要更新指针，不需要原子操作增加引用计数。

std::shared_ptr<int> sp1 = std::make_shared<int>(100);
std::shared_ptr<int> sp2 = std::move(sp1);  // 高效，引用计数不变
// sp1 变为空

24.7 知识体系总览

下面这张图帮你理清本章的核心脉络：

24.8 避坑指南

最后，分享几个我踩过的坑：

1. 不要对 const 对象使用 std::move：const T&& 会退化成 const T&，最终还是调用拷贝构造。我曾经在 const 对象上用了 move，结果性能毫无提升，排查了半天才发现问题。
2. 移动后不要依赖原对象的状态：虽然标准库保证移动后的对象处于“有效”状态，但具体内容未定义。比如 std::string 移动后可能是空字符串，也可能是其他值。别去猜，直接重新赋值。
3. 在泛型代码中，用 std::forward 而不是 std::move：如果你写模板函数，不确定参数是左值还是右值，用 std::forward 才能做到“完美转发”。
4. 移动构造函数和移动赋值要成对实现：只实现移动构造而不实现移动赋值，在某些场景下会退化成拷贝。我建议要么都实现，要么都用 = default（如果成员都支持移动）。

移动语义和完美转发，说白了就是让C++程序员能精细控制资源的“搬运”方式。用好了，性能提升立竿见影；用不好，也就是多几行代码的事。多写几次，自然就熟练了。

---