C++左值和右值

判据一：有没有身份#

有身份（identity）指这个表达式对应着一个能定位的具体对象——它有确定的存储位置，原则上可以取地址，能和别的对象区分开。判断方法很直接：看能不能对它用 & 取地址。

1
int x = 5;
2
int* p = &x;          // OK：x 有身份，&x 就是它的地址
3
// int* q = &(x + 1); // 编译错误：x + 1 算完就没了，没有对象供你指向

有名字的变量 x 是最典型的有身份表达式：它稳稳待在内存某处，&x 随时能取到。而 x + 1 只是一次运算的结果，没有名字、也没有一个持久对象让你指向，就是”无身份”的。

判据二：能不能移动#

可移动（movable）说的不是”这个对象有没有资源可偷”，而是”这个表达式指向的对象，用完之后还会不会再被用到”。

• 有名字的变量 x，后面随时可能再被读到、改到，语言就不敢让它被悄悄掏空——所以具名对象作为表达式不可移动。
• x + y、foo() 这种没名字的临时结果，语句一结束就消失，没人再看得到它，可以放心把里面的资源搬走——它们可移动。

下面这个例子能体会到区别（std::string 内部持有一块堆缓冲）：

1
std::string a = "hello";
2
std::string b = a;          // a 后面还可能用到 → 只能整份复制一遍
3
std::string c = a + "!";    // a + "!" 是临时值，用完就没 → 可以把它的
4
                            // 内部缓冲直接搬给 c，不必再复制

所以并不是”什么都可移动”。正是”有没有名字、之后还用不用得着”这条线，把可移动和不可移动分开。

这两个属性两两组合，就划出了下面的值类别。

三个基本类别#

• lvalue（左值）：有身份、不可移动。有名字的变量 x、解引用 *p、数组元素 a[i]、前置自增 ++x 都是左值。字符串字面量 "hello" 也是左值——它是一个有存储的 const char 数组。
• prvalue（纯右值）：无身份、可移动。字面量 42、true、nullptr，算术表达式 a + b，后置自增 x++，取地址 &x，以及按值返回的函数调用 foo()，都是纯右值。它表达的是”一个值”本身，而不是某个具名对象。
• xvalue（将亡值）：有身份、可移动。它指向一个确实存在的对象，但这个对象即将结束生命、资源可以被复用。最典型的是 std::move(x)，以及返回类型为 T&& 的函数调用。

两个并出来的类别#

• glvalue（广义左值） = lvalue + xvalue：凡是”有身份”的表达式。
• rvalue（右值） = prvalue + xvalue：凡是”可移动”的表达式。

xvalue 同时属于 glvalue 和 rvalue——它既有身份又可移动。这正是 C++11 专门补上的一类：用来表达”这个有名有址的对象，你可以把它搬走”。

说的是表达式，不是变量或类型#

一个反复出现的混淆需要先澄清：左值 / 右值说的是表达式，不是变量、也不是类型。int&& 是一种右值引用类型，但一个类型为 int&& 的具名变量，它作为表达式时却是个左值：

1
int&& r = 42;    // r 的类型是右值引用（int&&），它绑住了一个右值
2
int* p = &r;     // 但 r 作为表达式是左值：它有名字、能取地址
3
r = 10;          // 也能给它赋值——这都是左值才做得到的事

“类型是右值引用”和”作为表达式是左值”是两回事——想把这样一个具名的右值引用重新当右值用，得靠 std::move。

为什么 *p 是左值#

解引用 *p 看着像一步操作（地址 → 值），很容易以为它算出的是个临时右值。其实恰好相反：*p 不是“读出一个值”，而是“指认一个对象”——它不是 p 所指地址里存着的那个数，而是那块存储本身，只不过换用指针来称呼它。所以它有身份，对应一个确定的、已经存在的对象；判据也都对得上：*p = 42 能写进去、&*p 能取到地址（结果正是 p）、int& r = *p; 能绑非常量左值引用——这些都是只有左值才做得到的。

那“从地址把值读出来”这一步去哪了？它确实存在，但那是另一回事：只有当上下文需要一个值时（比如 int x = *p; 要拿 *p 的内容来初始化 x），编译器才在这个左值之上再叠一层左值到右值转换（lvalue-to-rvalue conversion），把对象里的值取出来。换句话说，*p 本身始终是左值；要不要真的“加载进寄存器”，取决于你怎么用它——用作赋值目标、取地址、绑引用时，它自始至终就是那个对象，根本没有读值这一步。你设想的“地址 → 临时值”，正是这层转换，而不是 *p 本身。

* 和 & 的对称也能佐证：& 吃一个左值（对象）、吐出一个纯右值（地址）；* 吃一个指针值（地址）、吐出一个左值（那个对象）。两者互逆，&*p 又变回 p。所以 * 的结果天然就是“对象”，也就是左值。

为什么 x++ 是纯右值#

同样的判断反过来用在后置自增 x++ 上：它是纯右值，而前置自增 ++x 是左值，差别正好落在“表达式给你的是对象、还是一个独立的值”上。

• ++x 先把 x 加一，再把 x 本身交给你——结果就是那个已经变大的 x，所以 ++x = 0、&++x、int& r = ++x; 都合法，它是左值。
• x++ 也把 x 加一，但它交给你的是 x 原来的值。可 x 此刻已经变成新值了，这个“旧值”不再存在于任何具名对象里，只能被复制成一个临时快照返回。这个快照没有身份、没有地址：x++ = 0、&(x++)、int& r = x++; 全部非法。所以 x++ 是纯右值。

用类类型的运算符重载写出来，两者的返回方式一目了然：

1
T& operator++();      // 前置：改完把对象自己按引用返回 → 左值
2
T  operator++(int);   // 后置：先存下旧值，改完把旧值按值返回 → 纯右值

（后置版多出来的那个 int 形参不接收任何实参，只是用来和前置版区分。）后置按值返回一个旧值的副本，正是纯右值的来历；对内建类型两种写法开销一样，但对迭代器等类类型，it++ 要多造一个副本，所以循环里习惯写 ++it。

左值引用：T& 与 const T&#

左值引用 T& 只能绑（非常量）左值，绑不了右值：

1
int x = 5;
2
int& r = x;        // OK：x 是左值
3
// int& bad = 42;  // 错误：42 是右值，非常量左值引用绑不上

常量左值引用 const T& 放宽了限制：左值、右值都能绑。绑到右值时，那个临时对象的生命周期会被延长到引用存在的这段时间：

1
int x = 5;
2
const int& a = x;    // OK：绑左值
3
const int& b = 42;   // OK：绑右值，临时量的生命周期被延长到 b

这就是只读形参惯用 const T& 的原因——一个签名同时接住有名对象和临时量，还不产生拷贝：

1
void print(const std::string& s);   // 左值、临时量都能传，且都不拷贝
2
std::string name = "Bob";
3
print(name);        // 传左值
4
print("literal");   // 传临时量

右值引用 T&&#

右值引用 T&&（C++11 引入）正好相反：只绑右值（纯右值和将亡值），不绑左值。

1
int&& r = 42;      // OK：绑右值
2
// int&& bad = x;  // 错误：x 是左值

它的意义是给函数一个信号：形参写成 T&&，就表示”这是个临时的、之后没人再用的对象，我可以放心把它搬空”。移动语义正是建立在这个信号上。

常量右值引用 const T&&#

常量右值引用 const T&& 也只绑右值、不绑左值，这点和 T&& 一样；差别在于它把被引用的对象看作只读。既然不能改，也就没法”搬空”它——所以 const T&& 几乎给不了移动的好处（一个 const 对象本来也无法被移动）。它和 T&& 的分工是：T&& 只绑非 const 右值，const T&& 连 const 右值也能绑。

对同一个右值实参，几种引用的偏好次序是：T&& 最优、其次 const T&&、最后 const T&（T& 根本绑不上右值）。既然 const T&& 搬不动东西，它的用途很窄，最典型的是把它 = delete 掉来禁止函数接收右值实参——它对右值的匹配优先于 const T&，删掉它就能精准拦下所有右值、同时放行左值：

1
void use(const std::string& s);          // 左值、临时量本来都能接
2
void use(const std::string&&) = delete;  // 删掉右值重载：它比上面更匹配右值 → 传临时量编译报错

标准库的 std::ref / std::cref 就是用这个办法（删掉 const T&& 重载）防止你把引用包到一个临时量上、用的时候悬垂。

一个陷阱：具名的右值引用是左值#

最后一个坑最反直觉：具名的右值引用本身是左值。

1
void sink(std::string&& s) {   // s 绑定到一个右值
2
    std::vector<std::string> v;
3
    v.push_back(s);              // 拷贝！s 作为表达式是左值
4
    v.push_back(std::move(s));   // 移动：显式转回右值
5
}

道理是：s 有名字、有稳定地址，你能对它取地址，所以它是左值。“它的类型是右值引用”和”它作为表达式是左值”是两回事。想再把它当右值用，需要 std::move 转一下。

参数：为什么左值、右值都能接#

形参写成 T&&，而 T 是待推导的模板参数——这让它成为转发引用（forwarding reference），而不是普通右值引用。普通右值引用（比如具体类型的 std::string&&）只接右值；转发引用则借助模板推导加引用折叠，接住一切：

引用折叠的规则是“沾上左值引用就塌成左值引用”：U& &、U& &&、U&& & 都折叠成 U&，只有 U&& && 折叠成 U&&。所以传左值时形参是 U&、传右值时是 U&&，两者都能绑上——std::move 因此对实参来者不拒。

顺带一提：无论 t 的类型是 U& 还是 U&&，t 本身是个有名字的参数，作为表达式永远是左值（正是前面那条“具名右值引用本身是左值”）。所以函数体里必须再 static_cast 一次，把它转回右值——std::move 自己就踩在它要替你解决的那个坑上。

返回类型：remove_reference_t 是关键#

返回类型为什么不直接写 T&&，而要先 remove_reference_t<T> 再加 &&？因为直接写 T&& 会被引用折叠毁掉：传左值时 T 推导成 U&，T&& 就是 U& &&，折叠成 U&——一个左值引用。那样函数会返回左值，static_cast 等于白转。

先用 remove_reference_t<T> 把 T 里的引用剥掉得到 U，再加 &&，返回类型就恒为 U&&——无论传进来的是左值还是右值，std::move 的结果永远是右值引用类型的 xvalue。这就是它能“无条件转成右值”的全部秘密。

为什么能传右值，传了又会怎样#

既然形参是转发引用、又无条件转成右值，那“std::move 把左值转成右值”其实是个不完整的说法：它根本不检查实参是左值还是右值，“把左值转成右值”只是它唯一有用的场景。它机械做的事是“把任何实参转成右值”——对一个本来就是右值的实参，这个转换是空转。

所以 std::move(42)、std::move(foo()) 合法但多余，有时还有害：

1
int&& r1 = 42;             // OK：临时量直接绑到引用，生命周期延长到 r1
2
int&& r2 = std::move(42);  // 悬垂：临时量在 std::move 内部产生，
3
                           // 引用穿过函数返回后不再延长它的生命周期

它不保证真的移动#

std::move 只改值类别，能不能真的移动，由重载决议和类型说了算。最常见的意外是对 const 对象用它：

1
const std::string a = "hi";
2
std::string b = std::move(a);   // 看着像移动，其实是拷贝

std::move(a) 的类型是 const std::string&&（const 不会被去掉）。移动构造的形参是非 const 的 std::string&&，接不住 const 右值；能接住它的反而是拷贝构造的 const std::string&——于是重载决议选了拷贝。同理，一个类型如果压根没写移动构造，std::move 之后也照样退回拷贝。

std::move 给不了“一定移动”的保证，它只是把话递到重载决议面前。

经验法则：只对“确实不再需要、且非 const 的具名左值”用 std::move；对右值、对 const 对象用它，轻则无用，重则悄悄变成拷贝或制造悬垂。

深拷贝的浪费#

• 源对象是个还要继续用的左值时，复制它必须深拷贝：另开一块内存、逐个复制元素，得到两份独立的数据。
• 但源对象要是个右值——一个马上就要析构的临时量——再深拷贝就是浪费：反正它下一刻就没了，不如直接把它的内部指针”偷”过来，让新对象接管那块内存，再把源对象的指针置空。这就是移动。

移动只改了几个指针，不复制底层数据，因此对持有大量堆资源的对象快得多。

移动构造是怎么来的，怎么写#

移动构造函数（连同移动赋值）是 C++11 才加进标准的新成员函数，和右值引用是一起引入的——正因为有了 T&& 这种”只绑右值”的引用，编译器才第一次有办法区分”实参是个还要用的左值”和”用完即弃的右值”，进而给后者选一条更快的路径。C++11 之前一个类只有拷贝构造 T(const T&)，源对象是不是临时的都只能深拷贝。

C++ 靠重载让编译器自动选版本：拷贝构造收 const T&，移动构造收 T&&。

1
class Buffer {
2
    int*   data_;
3
    size_t size_;
4
public:
5
    Buffer(const Buffer& other);      // 拷贝构造：深拷贝
6
    Buffer(Buffer&& other) noexcept;  // 移动构造：偷指针
7
};

实参是右值时，重载决议优先选 Buffer&& 版本（移动）；是左值时选 const Buffer& 版本（拷贝）。移动构造的典型写法就是”偷指针 + 源置空”：

1
Buffer(Buffer&& other) noexcept
2
    : data_(other.data_), size_(other.size_) {  // 接管对方的内存
3
    other.data_ = nullptr;   // 源置空，避免两个对象析构同一块内存
4
    other.size_ = 0;
5
}

那个 noexcept 不是可有可无的：像 std::vector 扩容搬元素时，只有在移动构造保证不抛异常的前提下，容器才敢用移动来搬，否则会退回用拷贝以保证异常安全。所以移动操作习惯上都标 noexcept。

被移动后的对象#

被移动后的对象处于”有效但未指定”的状态：还能安全析构、还能被重新赋值，但不应假设它的具体值。标准库类型（如 std::string）被移动后通常变空，但标准只保证”有效”，不保证”为空”。

用 std::move 把一个具名左值转成右值，就能主动触发这套移动：

1
std::string a = "hello";
2
std::string b = std::move(a);  // std::move 把 a 转成右值 → 触发移动构造
3
// 此后 a 处于有效但未指定的状态，别再依赖它的值

Rule of Five（五法则）#

一旦一个类自己管理资源（裸指针、文件句柄、锁等），就要考虑五个特殊成员函数。把它们摆在一起，形式上的差别一目了然：

1
class Buffer {
2
public:
3
    ~Buffer();                                   // 析构函数
4
    Buffer(const Buffer& other);                 // 拷贝构造：收 const 左值引用
5
    Buffer(Buffer&& other) noexcept;             // 移动构造：收右值引用
6
    Buffer& operator=(const Buffer& other);      // 拷贝赋值：收 const 左值引用
7
    Buffer& operator=(Buffer&& other) noexcept;  // 移动赋值：收右值引用
8
};

对比它们的形式：

• 拷贝的两个收 const T&（只读源对象），移动的两个收 T&&（要把源对象搬空，所以不能带 const），移动操作还习惯标 noexcept。
• 两个构造函数没有返回类型；两个赋值运算符返回 T&（返回自身的引用），好支持 a = b = c 这样的连写。
• 析构函数只有一个，不区分调用它的对象是左值还是右值。

Rule of Five 是说：这五个里只要手写了任意一个，往往意味着五个都得一起考虑，否则编译器生成的默认版本可能做错事——比如默认拷贝是浅拷贝，会让两个对象析构同一块内存。

Rule of Zero（零法则）#

与之相对的是 Rule of Zero：如果类的每个成员都自己管好自己的资源（用 std::vector、std::string、std::unique_ptr 等 RAII 类型做成员），这个类就不需要写任何特殊成员函数，编译器自动生成的拷贝 / 移动都正确。实践中优先追求零法则。

这里有个联动规则要注意：一旦你声明了拷贝构造 / 拷贝赋值 / 析构中的任何一个，编译器就不会再自动生成移动操作。这样的类只能拷贝、不能移动，可能悄悄损失性能。所以要么全都不写（零法则），要么该写的都写全。

引用限定符#

成员函数还能按”调用它的那个对象”是左值还是右值来重载，这叫引用限定符（ref-qualifier）：

1
class Widget {
2
    std::vector<int> data_;
3
public:
4
    // 在左值对象上调用：返回内部数据的只读引用，不拷贝
5
    const std::vector<int>& data() const & {
6
        return data_;
7
    }
8
    // 在右值对象上调用：对象反正要没了，直接把成员搬出来
9
    std::vector<int> data() && {
10
        return std::move(data_);
11
    }
12
};

当 Widget 是个临时量（右值）时，w.data() 选中 && 版本，直接把内部的 data_ 移动出来，省掉一次拷贝；对左值对象则安全地返回引用。