3. 右值引用：T&& 的语法，右值引用只能绑定到右值，延长临时对象生命周期

好，咱们来聊聊右值引用。说实话，我第一次看到 T&& 这个语法时，第一反应是「这什么鬼？两个取地址符？」后来才明白，这是 C++11 里最核心的语法糖之一。嗯，它解决了一个长期困扰 C++ 程序员的问题——临时对象的生命周期管理。

3.1 什么是右值引用？

右值引用，说白了就是专门用来绑定「临时对象」的引用。它的语法是 T&&。你可能会问：「普通引用 T& 不也能绑定对象吗？」没错，但普通引用有个限制——它只能绑定左值（可以取地址的、有名字的变量）。而右值引用恰恰相反，它只能绑定右值（临时对象、字面量、即将销毁的值）。

我举个例子你就明白了：

int a = 42;
int&  ref1 = a;   // 正确：a 是左值
int&  ref2 = 42;  // 错误：42 是右值，不能绑定到左值引用

int&& rref1 = 42; // 正确：42 是右值
int&& rref2 = a;  // 错误：a 是左值，不能绑定到右值引用

看到没？这就是最直观的区别。左值引用和右值引用，各自有各自的「领地」，互不侵犯。

3.2 右值引用的核心能力：延长生命周期

这里有个关键点——右值引用能延长临时对象的生命周期。你想想看，临时对象本来在表达式结束后就销毁了，但如果你用右值引用接住它，它的生命周期就会延长到引用本身的生命周期结束。

我在项目中遇到过这样一个场景：

std::string get_name() {
    return "C++移动语义";
}

// 普通用法：临时对象在分号处销毁
const std::string& name1 = get_name(); // 左值引用也能延长，但有限制

// 右值引用：明确表示我们绑定的是一个临时对象
std::string&& name2 = get_name(); // 生命周期延长到 name2 销毁
std::cout << name2 << std::endl; // 安全使用

这里要注意，const T& 也能延长临时对象的生命周期，但它有个问题——你不能修改它。而右值引用 T&& 允许你修改这个临时对象。这为后面的移动语义铺平了道路。

3.3 右值引用的本质：区分「可窃取」的对象

为什么 C++ 要引入右值引用？我个人习惯从「所有权」的角度来理解。左值代表「我还有用的对象」，你不能随便动它；右值代表「即将销毁的对象」，你可以放心地「偷」它的资源。

来看一个更实际的例子：

class Buffer {
    char* data_;
    size_t size_;
public:
    Buffer(size_t size) : size_(size) {
        data_ = new char[size_];
    }
    
    // 拷贝构造函数（深拷贝）
    Buffer(const Buffer& other) : size_(other.size_) {
        data_ = new char[size_];
        memcpy(data_, other.data_, size_);
    }
    
    // 移动构造函数（偷资源）
    Buffer(Buffer&& other) noexcept 
        : data_(other.data_), size_(other.size_) {
        other.data_ = nullptr;  // 置空，防止析构时释放
        other.size_ = 0;
    }
    
    ~Buffer() { delete[] data_; }
};

Buffer create_buffer() {
    return Buffer(1024);  // 返回临时对象
}

int main() {
    Buffer b1(1024);           // 普通构造
    Buffer b2(std::move(b1));  // 强制转为右值，触发移动构造
    Buffer b3 = create_buffer(); // 临时对象，触发移动构造
}

你看，当 create_buffer() 返回临时对象时，编译器会优先选择移动构造函数（如果有的话）。移动构造只是「偷」了源对象的指针，然后置空源对象。这比深拷贝快得多——尤其是当数据量很大时。

3.4 右值引用的避坑指南

这一点特别容易搞混。你看：

void foo(int&& rref) {
    // 在这里，rref 本身是左值！
    // 因为它有名字，可以取地址
    bar(rref);  // 糟糕！这里传递的是左值，不会触发移动语义
}

void bar(int&& rref) {
    // 这才是真正的右值引用
}

为什么会这样？因为 rref 是一个有名字的变量，它本身是左值。如果你想把它当作右值传递下去，必须用 std::move：

void foo(int&& rref) {
    bar(std::move(rref));  // 正确：显式转换为右值
}

嗯，这里有个口诀：「右值引用类型的变量，本身是左值。」记住这句话，能避免很多 bug。

3.5 右值引用的知识体系

下面这张图帮你理清右值引用的核心逻辑：

3.6 右值引用的实际应用场景

在实际项目中，右值引用最常见的用途有两个：

1. 移动构造函数和移动赋值运算符——避免深拷贝，提升性能
2. 完美转发——保持参数的左值/右值属性不变（下一章会详细讲）

我建议你在写类的时候，如果类管理了资源（比如动态内存、文件句柄、网络连接），一定要考虑实现移动语义。这不仅仅是性能优化，有时候甚至是功能上的需求——比如 std::unique_ptr 只能移动不能拷贝。

int a = 42;
static_assert(std::is_lvalue_reference_v<decltype((a))>);  // true
static_assert(!std::is_lvalue_reference_v<decltype((42))>); // true

3.7 右值引用与性能

我记得有一次优化一个图像处理库，里面有个 Image 类，存储了数百万像素的数据。原来的代码大量使用拷贝构造，导致性能瓶颈。加上移动构造后，性能提升了将近 10 倍。说白了，右值引用就是让 C++ 在「值语义」下也能达到「引用语义」的性能。

来看一个性能对比：

嗯，这里要提醒一下：移动语义不是万能的。对于基本类型（int、double 等）和小对象，拷贝和移动的性能差别不大。我建议你只在管理了堆内存或系统资源的类上实现移动语义，不要过度设计。