C++11 移动语义全面详解

前言 ------为什么 C++ 需要引入移动语义？

在 C++98/03 时代，对象传递（构造、赋值、函数传参、返回）只能靠拷贝。

假设我们有一个很大的 std::vector，里面存了 100 万个元素：

cpp 复制代码

std::vector<int> createBigVector() {
    std::vector<int> v(1'000'000);
    // 填充数据...
    return v;          // 这里发生了什么？
}

问题：

返回时，编译器会拷贝整个 vector（把 100 万个 int 全部复制一遍），时间复杂度 O(n)，非常慢！

同样的情况还出现在：

把大对象 push_back 到 std::vector、std::list 等容器
函数参数按值传递大对象
实现 swap、工厂函数返回大对象等场景

移动语义的诞生（C++11）就是要解决这个问题：

当对象即将被销毁（临时对象 / 右值）时，不再拷贝数据，而是直接"偷"走它的资源，让原对象变成"空壳"。整个操作几乎是 O(1) 常量时间。

这正是现代 C++ "零开销抽象"理念的完美体现。

左值与右值

要理解移动语义，必须先搞清楚值类别

值类别	特点	例子	能否取地址
左值	有名字、生命周期长、可被多次使用	int x = 10;、std::string s;	可以
右值	临时对象、表达式结束就销毁	10、std::string("hello")、函数返回的临时对象	不可以

更精确的划分（C++11 后）：

左值：std::string s;（普通变量）；

纯右值：10、字面量、临时对象；

将亡值：std::move(s) 后的对象。

右值引用------ 移动语义的语法基础

C++11 引入了 T&&（右值引用），它只能绑定到右值。

cpp 复制代码

int&  lref = 10;          // 错误！左值引用不能绑定右值
int&& rref = 10;          // 正确！右值引用可以绑定右值

std::string s = "hello";
std::string&& rref_str = std::move(s);   // 必须用 std::move 把左值转为右值

为什么需要右值引用？

它为编译器提供了一个"信号"：这个对象我不再需要了，你可以大胆偷它的资源。

std::move() 的本质

他其实什么都没移动！！！

cpp 复制代码

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

std::move 只是一个无条件的类型转换（cast），把左值强制变成右值引用。它不执行任何移动操作！
真正执行移动的是接收方的移动构造函数或移动赋值运算符。

折叠引用

很多人在看到 std::move 的源码时会产生疑问：

为什么参数是 T&&？如果传入的是左值，T 会推导成什么？会不会变成左值引用？

这里就用到了 C++11 引入的引用折叠规则。这是移动语义和完美转发的核心底层机制。

什么是折叠引用？

C++ 不允许直接写"引用的引用"（比如 int& & 或 int&& &），但在模板类型推导场景下，编译器内部会产生"引用叠加"。这时，编译器会按照引用折叠规则自动把它们"折叠"成单个引用。

引用折叠规则（C++11）非常简单，只有两条：

T& && → T& （左值引用 + 右值引用 → 左值引用）

T&& && → T&& （右值引用 + 右值引用 → 右值引用）

为什么 std::move 要用 remove_reference？

如果不加 remove_reference，直接写成 T&& 返回，可能会出问题：

假设我们传入一个左值 std::string s：

T 被推导为 std::string&（左值引用类型）

参数变成 std::string& &&

根据引用折叠规则 → std::string&（左值引用）

如果直接返回 T&&，就会返回左值引用，这就无法把左值转换成可移动的右值了！

所以标准库聪明地加了 std::remove_reference::type：

先把 T 中的引用去掉（remove_reference），得到纯类型 std::string

再加上 &&，得到 std::string&&

最后 static_cast 强制转换成右值引用

这样，无论你传入的是左值还是右值，std::move 最终返回的一定是右值引用，从而安全地触发移动语义。

代码演示：

cpp 复制代码

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

template<typename T>
void show_type(T&& param) {
    if (std::is_lvalue_reference<decltype(param)>::value) {
        std::cout << "左值引用\n";
    } else {
        std::cout << "右值引用\n";
    }
}

int main() {
    int x = 42;

    show_type(x);                    // 传入左值 → T 推导为 int&，T&& 折叠为 int&
    show_type(100);                  // 传入右值 → T 推导为 int，T&& 为 int&&
    show_type(std::move(x));         // 显式 move 后 → 右值引用

    return 0;
}

std::move vs std::forward 中的引用折叠

std::move：无条件转为右值引用（使用 remove_reference 保证一定是 &&）。
std::forward：有条件保留原值类别（完美转发），它依赖引用折叠 + 类型推导来实现"万能引用"

T&& 在模板参数中（且 T 是待推导类型）被称为万能引用，它既能绑定左值也能绑定右值，正是因为引用折叠规则在背后默默工作。

小结：

引用折叠不是 std::move 独有的机制，而是 C++11 右值引用体系的基础。它让模板能优雅地处理各种引用组合，从而实现了移动语义和完美转发两大特性。没有引用折叠，就没有可靠的 std::move。

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

一个类要支持移动，必须提供（或编译器自动生成）以下两个特殊成员函数：

cpp 复制代码

class MyVector {
    int* data = nullptr;
    size_t sz = 0;

public:
    // 1. 移动构造函数
    MyVector(MyVector&& other) noexcept 
        : data(other.data), sz(other.sz) {
        other.data = nullptr;   // 关键！必须清空原对象
        other.sz = 0;
    }

    // 2. 移动赋值运算符
    MyVector& operator=(MyVector&& other) noexcept {
        if (this != &other) {
            delete[] data;               // 先释放自己旧资源
            data = other.data;
            sz = other.sz;
            other.data = nullptr;
            other.sz = 0;
        }
        return *this;
    }

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

重要规则：

必须标记 noexcept（强烈推荐）。否则 std::vector 扩容时会退化成拷贝。

移动后，原对象必须处于有效但未指定状态。

移动后的对象是什么状态？

标准规定：移动后的对象必须仍然有效，你可以：

对它重新赋值；安全析构；调用不依赖具体内容的成员函数

cpp 复制代码

std::string s1 = "hello";
std::string s2 = std::move(s1);

std::cout << s1.empty() << "\n";   // 通常输出 1，但标准不保证
s1 = "world";                      // 完全合法

常见实际使用场景

1.容器操作

cpp 复制代码

std::vector<std::string> vec;
std::string s = "very long string...";
vec.push_back(std::move(s));     // 移动而非拷贝

2.unique_ptr 所有权转移

cpp 复制代码

auto ptr1 = std::make_unique<A>();
auto ptr2 = std::move(ptr1);     // ptr1 变为空

3.从函数返回大对象

cpp 复制代码

BigObject create() {
    BigObject obj;
    // ...
    return obj;          // 编译器会自动 move（即使不写 std::move）
}

4.实现高效 swap

cpp 复制代码

template<typename T>
void swap(T& a, T& b) {
    T tmp = std::move(a);
    a = std::move(b);
    b = std::move(tmp);
}

总结

移动语义是 C++11 最伟大的特性之一，它的核心思想是：

当对象即将被销毁时，不再复制数据，而是直接转移资源所有权。

通过右值引用 + std::move + 引用折叠规则 + 移动构造函数/赋值运算符，我们实现了性能与安全的完美平衡。

记住一句话：

std::move 不是移动，它只是"授权"移动；真正移动的是移动构造函数，而引用折叠是让这个授权在模板中可靠工作的关键机制。