Chapter 3: Move Semantics and Rvalue References
核心问题与阅读主线
移动语义解决的核心问题是:如何在满足 C++ 对象生命周期规则的前提下,把堆内存、文件句柄等独占资源的“深拷贝”转为“所有权转移”。本章沿 value category → 引用绑定 → std::move / std::forward → noexcept 主线,拆解 std::vector 扩容时如何权衡移动性能与强异常保证。
全章共用代码样本(下文各节持续拆解)
贯穿全章的材料是一个持有动态数组资源的简化 Buffer 类,用来观察资源所有权、深拷贝、移动接管、moved-from 状态,以及 std::vector<Buffer> 扩容时 move 与 copy 的异常安全取舍:
#include <algorithm>
#include <cstddef>
#include <utility>
class Buffer {
public:
Buffer() = default;
explicit Buffer(std::size_t n)
: data_(n == 0 ? nullptr : new int[n]), size_(n) {}
~Buffer() {
delete[] data_;
}
Buffer(const Buffer& other)
: Buffer(other.size_) {
std::copy_n(other.data_, size_, data_);
}
Buffer& operator=(const Buffer& other) {
if (this == &other) {
return *this;
}
Buffer tmp(other);
swap(tmp);
return *this;
}
Buffer(Buffer&& other) noexcept
: data_(std::exchange(other.data_, nullptr)),
size_(std::exchange(other.size_, 0)) {}
Buffer& operator=(Buffer&& other) noexcept {
if (this == &other) {
return *this;
}
delete[] data_;
data_ = std::exchange(other.data_, nullptr);
size_ = std::exchange(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:
int* data_ = nullptr;
std::size_t size_ = 0;
};
Buffer 的核心不变量是每块动态数组同一时刻只能由唯一对象负责 delete[] 释放:拷贝构造重新分配并复制元素,而移动构造只转移 data_ 与 size_,再把源对象置为可析构、可重新赋值且可调用 size() 的空状态。
3.1 value category:lvalue、rvalue 与表达式身份
每个 C++ 表达式同时拥有类型与 value category(见 C++ draft basic.lval),二者共同决定引用绑定、重载选择与资源可复用性。C++11 起基础类别分为三类,其中 xvalue 与 prvalue 合称 rvalue:
| value category | 是否有对象身份 | 资源是否可被复用 | 归属大类 | 典型表达式 |
|---|---|---|---|---|
lvalue | 是(可再次访问同一实体) | 否 | lvalue | 变量名 buf、*p、v[i]、返回左值引用的调用 |
prvalue | 否(纯值,用于初始化或运算) | 是 | rvalue | Buffer(1024)、按值返回 make_buffer()、字面量 42 |
xvalue | 是(即将消亡或被标记转移) | 是 | rvalue | std::move(buf)、返回 Buffer&& 的调用、static_cast<Buffer&&>(buf) |
下面代码展示表达式类别如何决定 use 的重载分支:
Buffer make_buffer() {
return Buffer(1024);
}
void use(const Buffer&);
void use(Buffer&&);
int main() {
Buffer buf(1024);
use(buf); // buf 是 lvalue,优先绑定到 const Buffer&
use(Buffer(2048)); // Buffer(2048) 是 prvalue,绑定到 Buffer&&
use(make_buffer()); // make_buffer() 是 prvalue,绑定到 Buffer&&
use(std::move(buf)); // std::move(buf) 是 xvalue,绑定到 Buffer&&
}
需要注意,buf 与 std::move(buf) 指向同一块栈对象,改变的只是表达式类别;而进入函数体后的具名右值引用形参,因为有了名字和可重复访问的身份,在表达式中仍属于 lvalue:
void forward_later(Buffer&& tmp) {
use(tmp); // tmp 是有名字的表达式,属于 lvalue
use(std::move(tmp)); // std::move(tmp) 转为 xvalue
}
边界与误区
声明类型是 Buffer&&,不代表表达式 tmp 是右值:对象存储位置(栈/堆)与声明类型均不决定重载路径,编译器只看调用点表达式的 value category。进入函数体后的具名形参 tmp 属于 lvalue,再次向下传出时必须显式写 std::move(tmp) 或 std::forward<T>(tmp);C++17 延后 prvalue 临时物化并引入强制拷贝省略,但重载匹配规则不变。
3.2 左值引用、右值引用与引用绑定
引用绑定规则将接口划分为“可修改借用”“只读借用”和“可消耗入口”三类:
| 形参类型 | 可绑定表达式 | 临时对象生命期与修改权 | 工程语义 |
|---|---|---|---|
T& | 可修改 lvalue | 不延长;可修改原对象 | 借用并修改,通常不接管资源 |
const T& | lvalue、xvalue、prvalue | 延长至引用作用域结束;只读 | 只读借用,或无移动路径时的拷贝入口 |
T&& | xvalue、prvalue | 延长至引用作用域结束;可非 const 修改 | 可消耗入口,允许接管或转移资源 |
利用这套规则可以把只读借用与资源接管拆成明确重载:
void inspect(const Buffer& b); // 只读取,不取得资源
void take(Buffer&& b); // 可以取得资源
Buffer a(1024);
inspect(a); // 读取已有对象
take(Buffer(2048)); // 取得临时对象资源
take(std::move(a)); // 取得 a 当前持有的资源
Buffer src(4096);
Buffer dst(std::move(src)); // src 仍存活且类不变量成立,析构可安全运行
核心判断
引用绑定与生命期延长只给语法许可,不等于资源已转移:std::move(old) 不创建对象也不分配内存,阅读 allocator_traits::construct(alloc, p, std::move(old)) 或 T&& x 函数时,必须继续确认目标构造或函数体是否执行了移动操作或 std::swap。const Buffer& 与 Buffer&& 绑定临时对象时都能延长生命期,区别仅在于后者允许非 const 修改。
3.3 std::move 与 moved-from 状态
std::move 的语义等价于无条件转换为右值引用类型(参见 std::move),它只把实参转换成 xvalue 表达式,本身不移动内存、不调用构造函数,也不修改对象成员。
图中 B 与 C 之间存在关键分工:std::move、std::move_iterator 与 std::move_if_noexcept 都只在转换点产生右值表达式,真正的资源转移发生在后续构造或写入目标对象的操作中。
移动完成后,源对象进入 moved-from 状态,此时对象仍处于生命周期内,退出作用域时析构函数仍会执行:
Buffer src(1024);
Buffer dst(std::move(src));
src = Buffer(256); // 重新赋值成立
src.size(); // size() 无资源访问前置条件
设计移动操作时需守住两条实现边界:
- 析构安全:
Buffer的移动构造用std::exchange将data_置空、size_归零,确保源对象析构时delete[] nullptr安全。 - 移动赋值与自移动:目标对象已存活时须先
delete[]释放旧资源再接管源对象,并处理自移动(Buffer以if (this == &other)保持原状,标准库通常仅保证 valid but unspecified state)。
边界与误区
moved-from 不等于“已析构”,也不等于“值保持原样”:标准库类型仅保证 valid but unspecified state(见 lib.types.movedfrom),即类不变量成立、可安全析构与重新赋值、可调用无前置条件的成员函数;具体值无稳定承诺,能否读取大小、访问元素或解引用(如 std::string、std::vector、std::unique_ptr)须以各类型前置条件为准。
3.4 forwarding reference、引用折叠与 std::forward
模板包装函数一旦给形参命名,函数体内的实参表达式就会退化为 lvalue;forwarding reference 配合 std::forward<T> 依据模板参数 T 还原调用点原有的值类别。
void sink(const Buffer&);
void sink(Buffer&&);
template <class T>
void bad_wrapper(T&& arg) {
sink(arg); // arg 为具名表达式,恒按 lvalue 调用 sink(const Buffer&)
}
template <class T>
void good_wrapper(T&& arg) {
sink(std::forward<T>(arg)); // 依据 T 恢复 lvalue 或 xvalue
}
当且仅当函数形参写成 T&& 且 T 是同一函数模板的 cv-unqualified 类型参数时,它才是 forwarding reference;带 const 限定或复用外层类模板参数的写法均为普通右值引用:
template <class T>
void f(T&& x); // forwarding reference
template <class T>
void g(const T&& x); // 普通右值引用,带 const 限定
template <class T>
struct Box {
void set(T&& x); // 普通右值引用(T 来自类模板)
template <class U>
void emplace(U&& x); // forwarding reference(U 来自成员函数模板)
};
当 lvalue 实参传入 T&& 时,T 推导为 Buffer&,编译器依据引用折叠(只有 && 与 && 组合得 &&,其余组合均折叠为 &)处理“引用的引用”:
| 中间形式 | 折叠结果 | 典型来源 |
|---|---|---|
T& & | T& | lvalue 实参传入 T&& 模板形参 |
T& && | T& | std::forward<T> 处理 lvalue 推导结果 |
T&& & | T& | 类型别名或 traits 组合 |
T&& && | T&& | rvalue 实参传入 T&& 模板形参 |
Buffer b(1024);
good_wrapper(b); // T 推导为 Buffer&,forward 后仍是 lvalue
good_wrapper(Buffer(2048)); // T 推导为 Buffer,forward 后是 xvalue
关键事实
std::forward<T>(arg) 必须传入推导出的模板参数 T;若误写为具体类型 std::forward<Buffer>(arg),会绕过引用折叠并将左值强行转为 xvalue。STL 的 emplace_back、make_unique、函数对象包装器及 allocator construct 路径均通过 std::forward<Args>(args)... 逐参数保留原值类别与 const 限定。
3.5 move constructor、move assignment 与 noexcept
移动构造从 rvalue 构造新对象,移动赋值则用 rvalue 改写已有对象;二者均须同时维护目标新状态、源对象 moved-from 状态以及异常安全边界:
| 特殊成员函数 | 目标对象前提 | 旧资源处理 | Buffer 实现要点 |
|---|---|---|---|
| Move Constructor | 正在构建新对象 | 无旧资源可释放 | std::exchange 接管 data_ 与 size_ 并置空源对象 |
| Move Assignment | 已存在,可能持有旧资源 | 须先 delete[] 释放旧资源 | 先做 this == &other 检查,释放旧数组后再 std::exchange |
Buffer(Buffer&& other) noexcept
: data_(std::exchange(other.data_, nullptr)),
size_(std::exchange(other.size_, 0)) {}
Buffer& operator=(Buffer&& other) noexcept {
if (this == &other) {
return *this;
}
delete[] data_;
data_ = std::exchange(other.data_, nullptr);
size_ = std::exchange(other.size_, 0);
return *this;
}
这两项实现仅包含指针/整数赋值与 std::exchange,不分配内存也不抛异常,因此标注 noexcept 有明确事实依据。
当 std::vector 扩容迁移元素时,若移动构造可能抛异常,中途失败会导致前几个旧元素已被移动置空而无法回滚;std::move_if_noexcept 正是为连接移动语义与强异常保证而设计:
template <class T>
void relocate_one(T* target, T& source) {
::new (target) T(std::move_if_noexcept(source));
}
source 作为具名变量本身是 lvalue:std::move_if_noexcept(source) 仅在 T 的移动构造为 noexcept 或无可用拷贝构造时返回 T&& 走移动路径,否则返回 const T& 回退到拷贝路径。
核心判断
编写移动操作时按四步确立异常契约,切勿为了性能盲目添加 noexcept:
- 明确类型独占的资源句柄。
- 明确源对象在 moved-from 后必须满足的操作集合(至少可析构、可重新赋值)。
- 核查迁移路径(含旧资源释放与指针交换)是否可能抛异常。
- 仅在确认不抛异常时标注
noexcept,让 STL 容器在扩容时敢于选择移动而非拷贝。
3.6 move 语义对 STL 容器扩容的影响
std::vector 维护一段连续存储;当插入导致元素数超出容量时,容器触发 reallocation(参见 vector.modifiers)。其对象迁移的典型生命周期路径可简化为以下伪代码:
// 伪代码:展示 vector 扩容时的对象迁移形状
new_storage = allocate(new_capacity);
constructed = 0;
try {
for each old element e:
construct(new_storage + constructed, std::move_if_noexcept(e));
++constructed;
construct(new_storage + constructed, new_element_arguments...);
} catch (...) {
destroy constructed elements in new_storage;
deallocate(new_storage);
throw;
}
destroy old elements;
deallocate(old_storage);
commit new_storage as vector state;
在 commit 之前,旧存储保持有效、新存储作为候选区构建;一旦任意构造抛出异常,容器只需销毁新存储中已构造的对象并释放新内存即可回滚。旧元素 e 在循环中是具名 lvalue,容器通过 std::move_if_noexcept(e) 决定每个元素走移动还是拷贝:
元素类型 T 的特征 | std::move_if_noexcept 返回 | 迁移成本与行为 | 异常发生时的状态边界 |
|---|---|---|---|
移动构造为 noexcept(如 Buffer) | T&&(xvalue) | 仅转移指针与大小,无深拷贝;全部成功后销毁旧 moved-from 对象 | 不抛异常,保持强异常保证 |
| 移动构造可能抛异常且拷贝构造可用 | const T&(lvalue) | 复制旧元素,旧存储保持原值 | 销毁新存储已构造元素并释放,旧 vector 完整保留(强异常保证) |
| 仅可移动且移动构造可能抛异常 | T&&(xvalue) | 无拷贝回退路径,只能移动旧元素 | 失去回滚能力,标准放宽强异常保证,效果可能变为 unspecified |
排查顺序
判断 std::vector<T> 扩容与失效行为时,按以下顺序逐项核对:
- 是否触发 reallocation:一旦重新分配,元素搬迁至新地址,旧指针、引用与迭代器全部失效(move 仅降低迁移成本,地址稳定性由容器存储模型决定)。
- 迁移策略选择:核对
T是否可拷贝、可移动,以及移动构造是否标注noexcept。 - 异常安全边界:评估
commit前发生异常时,旧存储是否仍可保持调用前状态。
最小自检任务
阅读下面代码,根据本章规则判断 A~E 各调用点的重载选择、src 的状态边界,以及 std::vector<Item> 扩容时选择 move 还是 copy:
#include <utility>
#include <vector>
struct Item {
Item() = default;
Item(const Item&);
Item(Item&&) noexcept(false);
};
void sink(const Item&);
void sink(Item&&);
template <class T>
void wrapper(T&& arg) {
sink(arg);
sink(std::forward<T>(arg));
}
int main() {
Item src;
sink(src); // A
sink(std::move(src)); // B
wrapper(src); // C
wrapper(Item{}); // D
std::vector<Item> v;
v.emplace_back();
v.emplace_back(); // E:假设这里触发扩容
}
本章知识点总结
- 表达式类别
value category 是表达式属性,与存储位置和声明类型共同影响重载决议;具名右值引用变量本身仍按
lvalue处理。 - 引用绑定
T&、const T&、T&&分别对应可修改借用、只读借用与可消耗入口;绑定与生命期延长只给语法许可,不自动转移资源。 - std::move 与 moved-from
std::move仅产生xvalue,真正转移由接收方执行;moved-from 对象仍在生命周期内,标准库一般仅承诺 valid but unspecified state。 - 完美转发
仅同级函数模板的 cv-unqualified
T&&是 forwarding reference,依赖引用折叠(全&&得&&,其余得&)与std::forward<T>保留实参值类别。 - 移动特殊成员
移动构造用
std::exchange接管资源并置空源对象;移动赋值须先释放目标旧资源并守住自赋值边界。 - noexcept 策略
真实不抛异常的移动操作才应标
noexcept,std::move_if_noexcept据此在容器扩容时决定走移动还是回退拷贝。 - vector 扩容
reallocation 先在新存储构造元素再切换状态并销毁旧存储;move 降低迁移开销,但无法阻止旧指针、引用和迭代器失效。