右值引用和移动语义

本节解决什么问题

考虑这样的场景：

std::vector<int> create_large_vector()
{
    std::vector<int> v(1000000);
    // ... 填充数据 ...
    return v;  // C++98 中会拷贝整个 vector！（非常慢）
}

在 C++98 中，函数返回大的对象时会发生深拷贝，性能很差。C++11 引入了移动语义，把"拷贝别人的数据"变成"偷走别人的数据"，大幅提高性能。

这个特性是什么

• 左值：有名字、可以取地址的对象。如变量 x、arr[0]。
• 右值：临时的、即将销毁的对象。如 42、x + y、std::move(x)。
• 右值引用 T&&：绑定到右值的引用。
• 移动语义：通过"偷"右值的资源而不是拷贝，来避免不必要的深拷贝。
• std::move：将左值转为右值引用，告诉编译器"这个对象我以后不再用了，你可以偷它的资源"。

C++ 标准版本

C++11

需要的头文件

#include <utility>  // for std::move, std::forward

基本语法

int&& rref = 42;           // 右值引用绑定到临时值
std::string&& sr = s1 + s2;  // 绑定到表达式结果

// std::move：把左值转为右值
std::vector<int> v1 = {1, 2, 3};
std::vector<int> v2 = std::move(v1);  // v1 的数据被"偷"到 v2，v1 变成空

左值 vs 右值速查表

示例代码

示例 1：拷贝 vs 移动——为什么需要移动语义

#include <iostream>
#include <vector>

int main()
{
    std::vector<int> v1 = {1, 2, 3, 4, 5};

    // 拷贝（两份独立的数据）
    std::vector<int> v2 = v1;
    std::cout << "after copy:\n";
    std::cout << "  v1 size = " << v1.size() << "\n";  // 5
    std::cout << "  v2 size = " << v2.size() << "\n";  // 5

    // 移动（v1 的数据被"偷"到 v3，v1 变成空）
    std::vector<int> v3 = std::move(v1);
    std::cout << "after move:\n";
    std::cout << "  v1 size = " << v1.size() << "\n";  // 0
    std::cout << "  v3 size = " << v3.size() << "\n";  // 5

    return 0;
}

运行结果：

after copy:
  v1 size = 5
  v2 size = 5
after move:
  v1 size = 0
  v3 size = 5

示例 2：在示例 1 基础上，自定义类的移动构造函数

#include <algorithm> // for std::copy
#include <iostream>
#include <string>
#include <utility>  // for std::move

class Buffer
{
    int* data;
    size_t size;

public:
    // 构造函数
    Buffer(size_t n) : data(new int[n]), size(n)
    {
        std::cout << "Constructor: allocated " << n << " ints\n";
    }

    // 拷贝构造函数（深拷贝）
    Buffer(const Buffer& other) : data(new int[other.size]), size(other.size)
    {
        std::copy(other.data, other.data + size, data);
        std::cout << "Copy constructor: deep copied " << size << " ints\n";
    }

    // 移动构造函数（偷数据）
    Buffer(Buffer&& other) noexcept
        : data(other.data), size(other.size)
    {
        other.data = nullptr;  // 让原对象安全析构
        other.size = 0;
        std::cout << "Move constructor: stole " << size << " ints\n";
    }

    ~Buffer()
    {
        delete[] data;
        std::cout << "Destructor\n";
    }

    size_t get_size() const { return size; }
};

int main()
{
    Buffer buf1(1000);

    // 拷贝：会触发深拷贝
    Buffer buf2 = buf1;
    std::cout << "buf1 size after copy: " << buf1.get_size() << "\n";

    // 移动：数据被偷走，没有深拷贝！
    Buffer buf3 = std::move(buf2);
    std::cout << "buf2 size after move: " << buf2.get_size() << "\n";
    std::cout << "buf3 size after move: " << buf3.get_size() << "\n";

    return 0;
}

运行结果：

Constructor: allocated 1000 ints
Copy constructor: deep copied 1000 ints
buf1 size after copy: 1000
Move constructor: stole 1000 ints
buf2 size after move: 0
buf3 size after move: 1000
Destructor
Destructor
Destructor

示例 3：在示例 2 基础上，移动语义让函数返回大对象高效

#include <iostream>
#include <vector>
#include <string>

// 返回大 vector（C++11 起自动启用移动语义，不需要手动 std::move）
std::vector<int> make_data(int n)
{
    std::vector<int> v(n);
    for (int i = 0; i < n; ++i)
    {
        v[i] = i * 10;
    }
    return v;  // ✅ 编译器自动移动（或 RVO 优化），不拷贝
}

int main()
{
    auto data = make_data(5);
    std::cout << "data: ";
    for (int n : data)
    {
        std::cout << n << " ";
    }
    std::cout << "\n";
    std::cout << "size = " << data.size() << "\n";

    // ⚠️ 错误做法：不要对返回值用 std::move！
    // auto data2 = std::move(make_data(5));  // ❌ 不要这样写！破坏 RVO 优化

    // ✅ 正确做法：赋值给已有变量时用 = std::move(source)
    std::vector<int> old = {100, 200};
    std::vector<int> fresh = std::move(old);  // 把 old 的内容移给 fresh
    std::cout << "old size = " << old.size() << "\n";      // 0
    std::cout << "fresh size = " << fresh.size() << "\n";  // 2

    return 0;
}

运行结果：

data: 0 10 20 30 40 
size = 5
old size = 0
fresh size = 2

运行结果

见上方每个示例的"运行结果"。

示例中的关键语法解释

为什么移动构造要写 noexcept

std::vector 扩容时要把旧元素搬到新内存。如果元素类型的移动构造可能抛异常，vector 为了保证异常安全，可能宁愿走拷贝构造。也就是说：你明明写了移动构造，但如果没写 noexcept，容器扩容时不一定用它。

class Buffer
{
public:
    Buffer(Buffer&& other) noexcept
    {
        // 偷资源，不抛异常
    }
};

这个差异在单独移动一个对象时看不明显；当 vector<Buffer> 大量 push_back 触发扩容时，是否 noexcept 才会影响容器选择移动还是拷贝。

std::move 什么时候该用，什么时候不该用

常见错误

错误 1：move 之后继续使用源对象

std::vector<int> a = {1, 2, 3};
std::vector<int> b = std::move(a);
std::cout << a[0];  // ❌ a 已经被"掏空"，行为未定义

正确做法：move 后不要再使用源对象，或者先检查是否为空。

错误 2：对 const 对象用 move

const std::vector<int> a = {1, 2, 3};
std::vector<int> b = std::move(a);  // ❌ 实际执行的是拷贝！const 对象不能移动

正确做法：move 不要用于 const 对象。

错误 3：给返回值加 std::move

std::vector<int> func()
{
    std::vector<int> v(1000);
    return std::move(v);  // ❌ 阻止了 RVO 优化！
}

正确做法：直接 return v;，编译器会自动优化。

错误 4：移动构造函数没有标记 noexcept

MyClass(MyClass&& other) { ... }  // 缺少 noexcept

正确做法：MyClass(MyClass&& other) noexcept { ... } — 不标记 noexcept 会导致 vector 等容器在扩容时退化为拷贝。

使用建议

1. return 时不要加 std::move：让编译器自动优化（RVO/NRVO）。
2. 赋值给已有对象时用 std::move(source)：用 target = std::move(source) 避免拷贝。
3. move 后不要再用源对象（除非重新赋值或重置）。
4. 移动构造函数必须标记 noexcept：否则 STL 容器在扩容时不会调用它。
5. std::move 不移动任何东西：它只是类型转换，把左值变成右值引用。真正的移动发生在移动构造函数或移动赋值运算符中。

小结

• 左值有名字、可取地址；右值是临时的（字面量、临时对象）。
• 右值引用 T&& 绑定到右值。
• 移动语义"偷"右值的资源，避免深拷贝。
• std::move(x) 把左值转为右值，告诉编译器"x 可以被偷"。
• return 局部变量时不要加 std::move（让编译器自己优化）。
• 移动构造函数必须标记 noexcept。

工程拓展

在 ROS2 中，发布消息、传输大量传感器数据（如点云、图像）时，移动语义能避免大数据拷贝。在 Boost.Asio 中，异步操作的回调参数大量使用移动语义来高效传递数据缓冲区。