一、移动语义与完美转发：从拷贝到移动的进化

大家好，我是你们的老朋友。今天我们来聊聊C++11引入的一个重量级特性——移动语义与完美转发。说实话，我刚接触这个主题时也觉得有点绕，但用熟了之后，你会发现它简直是性能优化的利器。

先问大家一个问题：为什么我们需要移动语义？

想象一下，你有一个装满数据的vector，要把它传给一个函数。传统做法是拷贝一份，原来的那份还留着。但很多时候，原来的那份我们根本不需要了。这就好比你去图书馆借书，明明可以借走，却非要自己手抄一本——浪费时间和精力。

1.1 左值与右值：身份的哲学

要理解移动语义，先得搞清楚左值和右值。我个人的理解很简单：

• 左值（lvalue）：有名字、能取地址、生命周期长。比如 int a = 5; 中的 a。
• 右值（rvalue）：没名字、不能取地址、临时存在。比如 5、a + b 的返回值。

嗯，这里要注意：C++11之后，右值又细分为纯右值和将亡值。但初学者先记住上面的区分就够了。

int x = 10;       // x 是左值，10 是右值
int y = x + 20;   // x + 20 是右值（临时结果）
int& ref = x;     // 左值引用，OK
int&& rref = 10; // 右值引用，OK（C++11新特性）
// int&& rref2 = x; // 错误！不能将左值绑定到右值引用

我在项目中遇到过一个问题：有人试图用 int&& 接收所有参数，结果发现左值传不进来。其实 int&& 只能绑定右值，左值得用 std::move 转换才行。

1.2 移动构造函数与移动赋值运算符

有了右值引用，我们就可以写出“偷资源”的构造函数了。来看一个简单的String类：

class MyString {
public:
    char* data;
    size_t size;

    // 普通构造函数
    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& operator=(MyString&& other) noexcept {
        if (this != &other) {
            delete[] data;          // 释放自己的资源
            data = other.data;      // 偷对方的资源
            size = other.size;
            other.data = nullptr;
            other.size = 0;
        }
        return *this;
    }

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

注意看移动构造函数：它没有重新分配内存，只是把指针“偷”了过来。这比拷贝构造快了一个数量级。我曾经在一个网络库中把大量字符串拷贝改成了移动，吞吐量直接提升了30%。

1.3 std::move：强制转换的“通行证”

std::move 其实不做任何移动操作。它只是一个类型转换，把左值变成右值引用。说白了，就是告诉编译器：“嘿，这个对象我不用了，你可以偷它的资源。”

MyString s1("Hello");
MyString s2 = std::move(s1); // 调用移动构造函数
// 此时 s1 处于“有效但未指定”状态，不要再使用！

我曾经犯过一个错误：移动完一个对象后，还继续使用它。结果数据全乱了。记住：被移动的对象仍然有效，但内容是不确定的。你可以重新赋值，但不要假设它原来的值还在。

1.4 std::forward：完美转发的“搬运工”

完美转发解决的是这样一个问题：我想写一个函数，把参数原封不动地传给另一个函数。如果参数是左值，就按左值传；如果是右值，就按右值传。

没有完美转发之前，你得写两个重载：一个接受左值引用，一个接受右值引用。有了 std::forward，一个模板函数搞定：

template<typename T>
void wrapper(T&& arg) {
    // T&& 是万能引用（不是右值引用！）
    // 如果传左值，T 推导为 T&，arg 是左值引用
    // 如果传右值，T 推导为 T，arg 是右值引用
    target(std::forward<T>(arg)); // 保持原始类型
}

这里有个关键点：T&& 在模板中叫“万能引用”或“转发引用”。它既能绑定左值，也能绑定右值。而 std::forward 的作用就是根据 T 的推导结果，决定返回左值引用还是右值引用。

我在写工厂函数时经常用到完美转发。比如创建一个智能指针：

template<typename T, typename... Args>
std::unique_ptr<T> make_unique(Args&&... args) {
    return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
}

这样，不管传进来的是左值还是右值，都能正确地转发给 T 的构造函数。

1.5 实战：vector的移动优化

最后，我们来看一个实战场景。标准库的 std::vector 已经完美支持移动语义。但如果你自己写容器，或者想理解背后的原理，可以看看这个例子：

class MyVector {
    int* data;
    size_t capacity;
    size_t size;

public:
    // 移动构造函数
    MyVector(MyVector&& other) noexcept
        : data(other.data), capacity(other.capacity), size(other.size) {
        other.data = nullptr;
        other.capacity = 0;
        other.size = 0;
    }

    // 移动赋值
    MyVector& operator=(MyVector&& other) noexcept {
        if (this != &other) {
            delete[] data;
            data = other.data;
            capacity = other.capacity;
            size = other.size;
            other.data = nullptr;
            other.capacity = 0;
            other.size = 0;
        }
        return *this;
    }

    // 插入元素时，如果容量不足，需要重新分配
    void push_back(int value) {
        if (size >= capacity) {
            // 关键：使用移动而非拷贝来转移已有元素
            size_t new_cap = capacity == 0 ? 1 : capacity * 2;
            int* new_data = new int[new_cap];
            
            // 对于基本类型，拷贝和移动没区别
            // 但对于复杂类型，这里应该用移动
            for (size_t i = 0; i < size; ++i) {
                new_data[i] = std::move(data[i]); // 使用移动
            }
            
            delete[] data;
            data = new_data;
            capacity = new_cap;
        }
        data[size++] = value;
    }
};

注意看 push_back 中的 std::move。对于 int 这样的基本类型，移动和拷贝没区别。但如果你的元素是 std::string 或自定义的复杂对象，移动就能避免深拷贝，大幅提升性能。

我记得有一次优化一个图像处理程序，里面有个 vector 存储了大量的像素块。每次扩容时，默认的拷贝操作导致程序卡顿。改成移动后，扩容时间从 200ms 降到了 5ms。这就是移动语义的威力。

好了，这一章的内容就到这里。移动语义是C++11的精华之一，理解它能让你的代码既快又优雅。下一章我们继续深入，看看其他STL容器的移动优化技巧。