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

想象一下搬家：把旧房子里笨重的书柜整个搬到新家，远比拆成木板、运过去再重新组装要快得多。C++的移动语义就是这个“整体搬运”的过程，它允许我们将一个即将消亡的对象的资源（如内存）直接“偷”过来，而不是进行昂贵的深拷贝。这是现代C++性能优化的核心武器。

左值、右值与将亡值

理解移动语义，必须先分清值的类别。一个简单的判断方法是：能否取地址。能取地址的是左值（lvalue），不能取地址的是右值（rvalue）。

右值引用（用 && 表示）就是用来绑定这些右值（包括纯右值和将亡值）的引用。它的核心目标是：延长临时对象的生命周期，并允许我们修改它。

int a = 10;
int& lref = a;       // 正确，左值引用绑定左值
// int& rref = 20;   // 错误！左值引用不能绑定右值（除非是const int&）
int&& rref1 = 20;    // 正确，右值引用绑定字面量右值
int&& rref2 = a + 5; // 正确，右值引用绑定表达式结果
// int&& rref3 = a; // 错误！右值引用不能直接绑定左值

移动构造函数与移动赋值

光有右值引用还不够，我们需要定义当用右值来构造或赋值时，具体做什么。这就是移动构造函数和移动赋值运算符。

来看一个管理堆内存的简单类 MyVector 的实现对比：

class MyVector {
private:
    int* data_;
    size_t size_;
public:
    // 1. 传统的拷贝构造函数（深拷贝，成本高）
    MyVector(const MyVector& other) : size_(other.size_) {
        data_ = new int[size_];
        std::copy(other.data_, other.data_ + size_, data_);
        std::cout << "拷贝构造" << std::endl;
    }

    // 2. 移动构造函数（资源转移，成本极低）
    MyVector(MyVector&& other) noexcept
        : data_(other.data_), size_(other.size_) { // 直接“偷”指针
        other.data_ = nullptr; // 关键！将源对象置空
        other.size_ = 0;
        std::cout << "移动构造" << std::endl;
    }

    // 类似的，还有移动赋值运算符 MyVector& operator=(MyVector&&)
    // 和拷贝赋值运算符 MyVector& operator=(const MyVector&)
    // ... 析构函数需要判断 data_ 是否为 nullptr
};

int main() {
    MyVector v1(1000); // 假设有构造函数分配1000个int
    MyVector v2 = v1;          // 调用拷贝构造，分配新内存并复制1000个元素
    MyVector v3 = std::move(v1); // 调用移动构造，仅转移指针，v1变为空
}

在实际项目中，一个包含大量 std::vector、std::string 的类，移动构造可能比拷贝构造快几十甚至上百倍，因为避免了所有元素的复制。

std::move 与 std::forward

这是两个用途不同但容易混淆的工具。

一个典型的 std::forward 应用是构造函数的参数转发，这在实现工厂函数或 emplace_back 类似功能时至关重要：

class Widget {
    std::vector<int> data;
public:
    // 完美转发构造函数
    template<typename... Args>
    Widget(Args&&... args) : data(std::forward(args)...) {}
    // 可以接受任意参数并完美转发给 data 的构造函数
};

Widget w1(10, 1); // 调用 vector(10, 1)
Widget w2 = {1, 2, 3}; // 调用 vector({1,2,3})

编译器何时选择移动？

当同时存在拷贝和移动版本的重载时，编译器遵循一套清晰的规则进行选择：

在返回值优化（RVO/NRVO）场景中，编译器甚至会直接省略拷贝或移动，在函数返回的目标位置直接构造对象。但实现移动语义仍然是必要的，因为它为编译器无法进行优化的情况提供了保障。

实践：实现一个简单的唯一指针

结合第25章的智能指针知识，我们可以实现一个简化版的 std::unique_ptr，它天然禁用拷贝，但支持移动：

template<typename T>
class SimpleUniquePtr {
    T* ptr_;
public:
    SimpleUniquePtr(T* ptr = nullptr) : ptr_(ptr) {}
    // 禁用拷贝
    SimpleUniquePtr(const SimpleUniquePtr&) = delete;
    SimpleUniquePtr& operator=(const SimpleUniquePtr&) = delete;

    // 实现移动
    SimpleUniquePtr(SimpleUniquePtr&& other) noexcept : ptr_(other.ptr_) {
        other.ptr_ = nullptr;
    }
    SimpleUniquePtr& operator=(SimpleUniquePtr&& other) noexcept {
        if (this != &other) {
            delete ptr_;        // 释放当前资源
            ptr_ = other.ptr_;
            other.ptr_ = nullptr;
        }
        return *this;
    }
    // ... 析构函数、operator*、operator-> 等
};

int main() {
    SimpleUniquePtr<int> p1(new int(42));
    // SimpleUniquePtr p2 = p1; // 错误！拷贝被禁用
    SimpleUniquePtr<int> p3 = std::move(p1); // 正确！所有权转移
    // 此时 p1 为空，p3 持有内存
}

这个例子清晰地展示了移动语义如何实现资源的独占所有权转移。实际开发中，大部分团队会直接使用 std::unique_ptr，但了解其原理至关重要。

class ResourceHolder {
    int* data;
public:
    ResourceHolder(int size) { data = new int[size]; }
    ResourceHolder(ResourceHolder&& other) : data(other.data) {}
    ~ResourceHolder() { delete[] data; }
};
int main() {
    ResourceHolder a(100);
    ResourceHolder b = std::move(a);
    // 程序结束时...
}