Skip to main content

Chapter 3: Move Semantics and Rvalue References

核心问题与阅读主线

本章导读6 个核心小节 · 附自检与总结

移动语义解决的核心问题是:如何在满足 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否(纯值,用于初始化或运算)是rvalueBuffer(1024)、按值返回 make_buffer()、字面量 42
xvalue是(即将消亡或被标记转移)是rvaluestd::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:

  1. 明确类型独占的资源句柄。
  2. 明确源对象在 moved-from 后必须满足的操作集合(至少可析构、可重新赋值)。
  3. 核查迁移路径(含旧资源释放与指针交换)是否可能抛异常。
  4. 仅在确认不抛异常时标注 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> 扩容与失效行为时,按以下顺序逐项核对:

  1. 是否触发 reallocation:一旦重新分配,元素搬迁至新地址,旧指针、引用与迭代器全部失效(move 仅降低迁移成本,地址稳定性由容器存储模型决定)。
  2. 迁移策略选择:核对 T 是否可拷贝、可移动,以及移动构造是否标注 noexcept。
  3. 异常安全边界:评估 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 降低迁移开销,但无法阻止旧指针、引用和迭代器失效。