 右值引用介绍)
前言
标题里的ravalue是rvalue的常见拼写笔误，标准术语是右值引用（rvalue reference），写作T&&。它随 C++11 引入，是移动语义（move semantics）和完美转发（perfect forwarding）的语言基础。没有右值引用，C++ 只能靠拷贝传递大对象，无法把「临时对象即将销毁」这一信息传递给构造函数或函数参数。
围绕右值引用有三个高频误解。第一，把std::move当成「执行移动」的函数；它实际上只是一个类型转换，把表达式转成右值引用，真正搬移资源的是移动构造或移动赋值。第二，看到T&&就认为是右值引用；在模板参数推导的上下文中，T&&可能是「转发引用」（forwarding reference），既能绑定左值也能绑定右值。第三，认为被移动后的对象「不能再用」；标准规定它处于「有效但未指定」状态，可以销毁、可以重新赋值，但不能假设它的值。
本文按值类别、引用折叠、移动语义、完美转发四条线展开，并用一个管理动态缓冲区的类演示移动构造、移动赋值和转发工厂。示例以 C++17 为基准；文中不声称代码经过编译或运行。
一、值类别与右值引用
C++ 的每个表达式除了有类型，还有值类别（value category）。粗略地分三类：
| 值类别 | 是否有身份 | 是否可被移动 | 典型例子 |
|---|
| 左值（lvalue） | 有 | 通常不，除非显式转换 | 变量名、*p、a[i]、返回引用的函数调用 |
| 纯右值（prvalue） | 无 | 是 | 字面量、临时对象、返回非引用的函数调用 |
| 将亡值（xvalue） | 有 | 是 | std::move(x)、static_cast<T&&>(x) |
右值引用只能绑定到纯右值和将亡值，不能绑定到普通左值；左值引用（非 const）只能绑定左值；const 左值引用两者都能绑定。这个绑定规则是重载决策的基础：一个函数同时提供f(const T&)和f(T&&)时，左值优先匹配前者，右值优先匹配后者。
需要特别注意：具名的右值引用变量本身是左值。例如T&& r = makeT();之后，表达式r是一个左值，因为它在内存中有名字、有身份。要把r继续当作右值传递，必须写std::move(r)。这一点是初学阶段最容易混淆的地方。
C++17 起，纯右值的初始化语义有所调整，许多场景下临时对象会被直接构造到目标位置（guaranteed copy elision），不产生移动或拷贝。但值类别的分类规则仍然是理解重载与转发的基础。
二、引用折叠与转发引用
右值引用出现在类型别名或模板参数中时，会发生引用折叠（reference collapsing）。规则只有四条：
| 组合 | 折叠结果 |
|---|
T& & | T& |
T& && | T& |
T&& & | T& |
T&& && | T&& |
可以记成：只要有一个左值引用参与，结果就是左值引用；只有两个都是右值引用时，结果才是右值引用。
引用折叠解释了转发引用。函数模板template <typename T> void f(T&& value)中，T是推导出来的：传入左值时，T被推导为U&，T&&折叠成U&；传入右值时，T被推导为U，T&&保持U&&。因此这个T&&既能接左值也能接右值，被称为转发引用（旧称万能引用）。
判断是不是转发引用，看两个条件：第一，形式必须是T&&；第二，T必须是在本次调用中推导的模板参数。类模板的成员函数template <typename T> class Box { void f(T&&); };里的T在类实例化时已经确定，f的参数不是转发引用，而是普通的右值引用。auto&&在范围 for 和变量声明中也是转发引用。
const T&&很少见：它绑定右值，但因为是 const，移动构造无法修改源对象，通常退化为拷贝。不要为了「接收右值」而写const T&&。
三、移动语义的五个要点
移动构造和移动赋值的目标是「接管资源，而不是复制资源」。实现时有五个要点：
- 偷指针并置空源对象。移动构造复制指针、尺寸等成员后，把源对象的指针设为
nullptr，避免两次析构重复释放。 - 标记
noexcept。移动操作通常不分配内存，应当承诺不抛；标准库容器在扩容时会据此选择移动而不是拷贝。 - 被移动对象保持有效。置空后的对象仍能析构、能重新赋值；不要读它的值，也不要依赖某个具体状态。
std::move只是转换。它等价于static_cast<T&&>(expr)，不调用任何移动函数。真正发生什么，取决于接下来匹配到哪个构造函数或赋值运算符。- 不要对返回的局部变量写
std::move。return std::move(local);会把本可触发的返回值优化（NRVO）变成一次移动，通常更差；直接return local;即可。
对const对象使用std::move会得到const T&&，它无法匹配T&&参数的移动构造，只能匹配const T&的拷贝构造，于是静默退化成拷贝。这是「以为移动了、其实复制了」的常见来源。
// 适用于 C++17
#include <cstddef>
#include <cstring>
#include <iostream>
#include <string>
#include <utility>
#include <vector>
class Buffer {
public:
explicit Buffer(std::size_t n = 0)
: data_(n != 0 ? new char[n] : nullptr), size_(n) {}
~Buffer() {
delete[] data_;
}
Buffer(const Buffer& other)
: data_(other.size_ != 0 ? new char[other.size_] : nullptr),
size_(other.size_) {
if (size_ != 0) {
std::memcpy(data_, other.data_, size_);
}
}
Buffer& operator=(const Buffer& other) {
if (this != &other) {
Buffer tmp(other);
swap(tmp);
}
return *this;
}
Buffer(Buffer&& other) noexcept
: data_(other.data_), size_(other.size_) {
other.data_ = nullptr; // 源对象置空，防止重复释放
other.size_ = 0;
}
Buffer& operator=(Buffer&& other) noexcept {
if (this != &other) {
delete[] data_;
data_ = other.data_;
size_ = other.size_;
other.data_ = nullptr;
other.size_ = 0;
}
return *this;
}
void swap(Buffer& other) noexcept {
std::swap(data_, other.data_);
std::swap(size_, other.size_);
}
std::size_t size() const noexcept { return size_; }
private:
char* data_;
std::size_t size_;
};
void inspect(int&) {
std::cout << "lvalue\n";
}
void inspect(int&&) {
std::cout << "rvalue\n";
}
template <typename T>
void forwarding(T&& value) {
inspect(std::forward<T>(value));
}
template <typename T, typename... Args>
T makeObject(Args&&... args) {
return T(std::forward<Args>(args)...);
}
int main() {
Buffer a(16);
Buffer b(std::move(a)); // 移动构造；a 之后不要读
b = Buffer(32); // 移动赋值
std::vector<Buffer> buffers;
buffers.push_back(Buffer(8)); // 右值进入容器，移动构造
buffers.emplace_back(4); // 原地构造
int x = 1;
forwarding(x); // T = int&，按左值转发
forwarding(2); // T = int，按右值转发
std::string s = makeObject<std::string>(3, 'x');
std::cout << s.size() << ' ' << b.size() << '\n';
return 0;
}Buffer的移动构造只复制两个成员并清空源对象，不分配内存，因此标noexcept是合理的。std::vector在扩容时如果看到移动构造是noexcept，就可以安全地移动旧元素；否则为了维持异常安全，可能选择拷贝。
四、完美转发：把值类别原样传下去
完美转发要解决的问题是：工厂函数、emplace、包装器接收到参数后，需要把参数按原来的值类别传给下层函数，既不能把右值变成左值，也不能把左值强行变成右值。std::forward<T>(arg)完成这件事：当T被推导为左值引用时，它返回左值；当T是普通类型时，它返回右值引用。
std::forward必须显式写出模板实参T，通常与转发引用成对出现：参数声明为T&&，转发时写std::forward<T>(arg)。如果只写std::forward(arg)，模板参数无法推导，会编译失败。
makeObject是典型写法：Args&&...接收任意参数，std::forward<Args>(args)...原样传给T的构造函数。标准库的std::make_unique、容器的emplace_back都采用同样的模式。它避免了「先构造临时对象再拷贝」的开销，但不会凭空创造性能；具体是否内联、是否省略临时对象，取决于编译器优化。
转发引用也有副作用：它的模板版本会匹配几乎所有类型，可能抢走本应走其他重载的调用。设计接口时，如果同时提供f(const T&)、f(T&&)和模板f(T&&)，要仔细检查重载决策；必要时用std::enable_if或 C++20 的 concepts 限制模板的适用范围。
常见坑点
- ❌ 认为
std::move(x)会执行移动。
✅ 它只把x转成右值引用；是否移动取决于目标类型是否有移动构造/赋值。
- ❌ 移动后继续读取源对象的值：
Buffer b(std::move(a)); use(a.size());
✅ 被移动对象只能销毁或重新赋值；需要旧值就先保存。
- ❌ 移动构造忘记把源对象的指针置空，导致两次
delete[]。
✅ 偷取后立即把源指针设为nullptr、尺寸设为 0。
- ❌ 移动构造不标
noexcept，std::vector扩容时改用拷贝。
✅ 确认移动操作不抛后标noexcept，并用static_assert检查。
- ❌
return std::move(local);
✅ 直接return local;，让编译器执行返回值优化。
- ❌ 对
const对象std::move，以为能调用移动构造。
✅ 结果是const T&&，通常绑定到拷贝构造；需要移动就不要加const。
- ❌ 把类模板成员函数里的
T&&当成转发引用。
✅ 转发引用要求T在本次调用中推导；类模板的T已固定，它是普通右值引用。
- ❌ 在转发函数里写
std::forward(arg)而不写模板实参。
✅ 写成std::forward<T>(arg)，与T&&参数配对。
总结
| 主题 | 关键结论 |
|---|
右值引用T&& | 绑定纯右值和将亡值；具名变量本身是左值 |
| 引用折叠 | 有左值引用参与就折叠为左值引用 |
| 转发引用 | 仅当T在调用中推导时成立 |
std::move | 只是static_cast<T&&>，不移动任何东西 |
| 移动后状态 | 有效但未指定；可析构、可赋值，不可读值 |
std::forward | 按T保留值类别，需显式模板实参 |
| 移动与容器 | noexcept移动构造让容器放心移动 |
右值引用本身不产生性能，它只是让「资源可以被接管」这件事在类型系统里表达出来。真正决定行为的是移动构造、移动赋值是否写对，以及noexcept、置空源对象、避免对 const 对象 move 这些细节。把这些细节处理好，移动语义才会按预期工作。
