Skip to main content

Chapter 9: Exception Safety

核心问题与阅读主线

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

STL 的异常安全聚焦一个核心工程问题:容器或算法执行中途若因构造、拷贝、移动、分配器或用户回调抛出异常,已构造对象与既有状态必须守住哪一级承诺。本章沿 std::vector::push_back 扩容路径,拆解 basic、strong、no-throw 三级保证的边界,以及 noexcept、RAII guard 与提交点如何共同落地回滚语义。

全章共用代码样本(下文各节持续拆解)

贯穿材料核心代码

本章的贯穿材料是一段向 std::vector<Record> 追加元素的代码:表面只是一次调用,内部却串起新存储分配、旧元素迁移、新元素构造、三指针提交与旧存储释放五个阶段:

#include <string>
#include <utility>
#include <vector>

struct Record {
std::string payload;

Record(std::string value) : payload(std::move(value)) {}
Record(const Record&) = default;
Record(Record&& other) noexcept : payload(std::move(other.payload)) {}
};

void append_record(std::vector<Record>& records) {
records.push_back(Record{"new-record"});
}

Record 的移动构造带有 noexcept,使 std::vector 在扩容时既能高效迁移旧元素,又能在新存储构造全数完成前守住旧 begin / end / capacity 状态——“先准备新状态,再一次性提交”是全章分析的核心模型。

9.1 basic、strong 与 no-throw guarantee​

异常安全承诺回答异常穿过函数边界时的两个问题:资源责任是否闭合、对象状态保持到何种程度。STL 将其划分为三级承诺:

承诺等级异常后对象与不变量状态资源责任实现结构与典型场景调用侧判断
basic guarantee对象仍有效(size() 可读、可正常析构并继续合法操作),但具体值可能改变无泄漏,资源责任闭合原地修改、部分插入、用户回调参与的复合赋值后续可安全析构与复用,但须重新检查值
strong guarantee保持调用前状态(commit / rollback,无任何可观察副作用)新建临时资源全数回滚释放两段式结构:临时区构造 + 短提交点(如 vector 扩容追加)失败后可直接沿用旧状态
no-throw guarantee承诺不向外传播异常清理或句柄交换稳定完成析构函数、deallocate、指针 swap、部分移动构造可安全放入清理、回滚与提交路径

以贯穿材料 records.push_back(Record{"new-record"}) 为例:扩容时若新存储分配失败,旧 records 原封不动;若迁移旧元素失败,已构造的新元素被销毁、新存储被释放,旧 records 仍指向旧存储。

边界与误区

注意

no-throw 清理路径是异常安全分析的支点:若析构函数或释放路径向外抛出异常,回滚逻辑会被新的异常打断,basic 与 strong 承诺随之失去支点。此外,strong guarantee 并非无条件成立——当元素移动构造可能抛出且无可用拷贝路径时,承诺会按元素类型能力降级(见 9.2)。

9.2 noexcept 与 move_if_noexcept 的选择规则​

noexcept 既是函数声明承诺,也是 STL 类型萃取读取的编译期证据,直接决定容器扩容的迁移路径:

  • std::move:无条件将表达式转为右值引用,不检查移动构造是否会抛出。
  • std::move_if_noexcept:专为强异常保证设计——仅当 T 的移动构造不抛异常或无可用拷贝构造时返回右值引用,否则返回 const T& 退回拷贝。

下面三组类型与 static_assert 直接展示了这条选择规则:

#include <type_traits>
#include <utility>

struct NoThrowMove {
NoThrowMove() = default;
NoThrowMove(const NoThrowMove&) = default;
NoThrowMove(NoThrowMove&&) noexcept = default;
};

struct ThrowingMoveCopyable {
ThrowingMoveCopyable() = default;
ThrowingMoveCopyable(const ThrowingMoveCopyable&) = default;
ThrowingMoveCopyable(ThrowingMoveCopyable&&) {}
};

struct MoveOnlyThrowing {
MoveOnlyThrowing() = default;
MoveOnlyThrowing(const MoveOnlyThrowing&) = delete;
MoveOnlyThrowing(MoveOnlyThrowing&&) {}
};

static_assert(std::is_same_v<decltype(std::move_if_noexcept(std::declval<NoThrowMove&>())), NoThrowMove&&>);
static_assert(std::is_same_v<decltype(std::move_if_noexcept(std::declval<ThrowingMoveCopyable&>())), const ThrowingMoveCopyable&>);
static_assert(std::is_same_v<decltype(std::move_if_noexcept(std::declval<MoveOnlyThrowing&>())), MoveOnlyThrowing&&>);

三种类型在 vector 扩容迁移时的分支与异常后状态如下:

元素类型特征std::move_if_noexcept 返回扩容迁移路径迁移中途抛出时的旧存储与异常保证
移动构造为 noexcept(NoThrowMove)NoThrowMove&&移动构造迁移阶段不抛异常;配合先构造新元素再迁移,strong guarantee 成立
移动可能抛出且可拷贝(ThrowingMoveCopyable)const ThrowingMoveCopyable&拷贝构造拷贝不改动旧对象;销毁新存储已构造元素并释放后,旧存储完整保留(strong guarantee)
仅可移动且移动可能抛出(MoveOnlyThrowing)MoveOnlyThrowing&&移动构造(无拷贝后路)已移动的旧元素进入 moved-from 状态,缺少完整回滚材料,强承诺退化

边界与误区

注意

noexcept 标注决定容器是否退化:

  1. 漏写 noexcept:真实无抛出的移动构造若漏写 noexcept(且类型可拷贝),vector 扩容会被迫退回逐个拷贝。
  2. 仅可移动且可抛出:对移动可能抛出且删除拷贝的 MoveOnlyThrowing,vector::push_back 与 vector::emplace_back 均说明强保证会放宽,异常后效果进入 unspecified。

9.3 RAII、commit / rollback 与资源恢复​

strong guarantee 依赖 RAII guard 与 commit / rollback 两段式结构协同落地:

  • RAII guard 闭合资源:在构造时接管临时存储,异常退栈时自动清理,提交成功后解除清理责任。
  • 短提交点切换状态:把可能抛出的分配、构造、拷贝与移动全数置于提交点之前;提交点本身只保留不抛异常的指针赋值、整数更新或资源句柄交换。

下面简化版 raw_buffer_guard 演示了 vector 扩容时的典型 guard 结构:

#include <cstddef>
#include <memory>

template <class T, class Alloc>
class raw_buffer_guard {
public:
raw_buffer_guard(Alloc& alloc, T* data, std::size_t capacity)
: alloc_(alloc), data_(data), capacity_(capacity), constructed_(0), active_(true) {}

void one_more_constructed() noexcept {
++constructed_;
}

void release() noexcept {
active_ = false;
}

~raw_buffer_guard() {
if (!active_) {
return;
}
for (std::size_t i = 0; i < constructed_; ++i) {
std::allocator_traits<Alloc>::destroy(alloc_, data_ + i);
}
std::allocator_traits<Alloc>::deallocate(alloc_, data_, capacity_);
}

private:
Alloc& alloc_;
T* data_;
std::size_t capacity_;
std::size_t constructed_;
bool active_;
};

raw_buffer_guard 通过四个成员守住两条不变量:

  • 精确范围析构:按 constructed_ 计数仅对 [0, constructed_) 内已构造对象调用 destroy,再整体 deallocate。
  • 提交前保留旧状态:在 release() 调用前不触碰旧 vector 的 begin / end / capacity,确保回滚目标完整。

边界与误区

注意

两条红线决定强异常保证是否成立:

  1. 清理与析构路径必须 no-throw:标准容器依赖元素析构、allocator_traits::deallocate 与 guard 析构完成回滚;若用户自定义析构向外传播异常,清理流程会被直接打断。
  2. 提交顺序不可倒置:若源码在迁移完成前提前覆盖容器三指针,一旦中途抛出,即使 guard 释放了新存储,旧状态指针也已丢失而无法回滚。

9.4 vector 扩容中的异常安全路径​

std::vector 触发扩容(size == capacity)时,重新分配会使所有旧迭代器、指针与引用失效;按 vector::push_back 规范,异常发生时原则上须保持无副作用(strong guarantee)。扩容追加的异常安全骨架如下:

关键事实

E[提交三指针] 是不可逆分水岭:提交前(B/C/D)允许抛异常,旧 vector 三指针未改写且由 guard 负责回收新存储;提交及清理旧存储(E/F)必须保持 no-throw。真实标准库通常如上图先构造新元素再迁移旧元素,以防 push_back(v[0]) 这类自引用入参在旧元素移动后失效。

下面的教学简化函数 reallocate_append 展示了 raw_buffer_guard、std::move_if_noexcept 与三指针提交点的代码落点(按右值入参先后移旧再构新):

#include <cstddef>
#include <memory>
#include <utility>

template <class T, class Alloc>
void reallocate_append(T*& begin, T*& end, T*& cap, Alloc& alloc, T&& value) {
const std::size_t old_size = static_cast<std::size_t>(end - begin);
const std::size_t new_capacity = old_size == 0 ? 1 : old_size * 2;

T* new_begin = std::allocator_traits<Alloc>::allocate(alloc, new_capacity);
raw_buffer_guard<T, Alloc> guard{alloc, new_begin, new_capacity};

std::size_t i = 0;
for (; i < old_size; ++i) {
std::allocator_traits<Alloc>::construct(
alloc,
new_begin + i,
std::move_if_noexcept(begin[i])
);
guard.one_more_constructed();
}

std::allocator_traits<Alloc>::construct(alloc, new_begin + old_size, std::move(value));
guard.one_more_constructed();

T* old_begin = begin;
T* old_end = end;
T* old_cap = cap;

begin = new_begin;
end = new_begin + old_size + 1;
cap = new_begin + new_capacity;
guard.release();

for (T* p = old_begin; p != old_end; ++p) {
std::allocator_traits<Alloc>::destroy(alloc, p);
}
std::allocator_traits<Alloc>::deallocate(alloc, old_begin, static_cast<std::size_t>(old_cap - old_begin));
}

这段实现靠三个设计支点支撑异常安全:

  • guard 兜底提交前失败:new_begin 由 guard 接管,构造循环或新元素构造抛出时自动销毁已构造元素并释放新存储。
  • 旧三指针延后提交:提交点之前 begin / end / cap 未改写,失败路径可直接沿用旧存储。
  • 真实 STL 的额外边界:标准库实现还需处理中间位置插入、自引用实参、容量上限检查、allocator propagation 规则与调试迭代器状态。

9.5 allocator 与容器插入失败恢复​

容器通过 std::allocator_traits<Alloc> 分离原始存储管理与对象生命周期(见 vector::emplace_back):

  • 两层对称原语:allocate / deallocate 管理原始存储,construct / destroy 管理单个 T 对象。
  • 按构造计数回收:若前 k 个对象构造成功、第 k + 1 次 construct 抛出,只能对这 k 个对象调用 destroy 后再释放存储;销毁未构造地址属于未定义行为(UB)。

不同失败阶段的恢复责任如下:

失败阶段存储与对象状态恢复动作对外异常状态
allocate 失败新存储尚未出现,旧存储完好无临时资源需清理,直接向上传播异常strong guarantee
新元素 construct 失败新存储已分配,可能含已构造对象guard 按已构造计数 destroy,再 deallocate 新存储strong guarantee
旧元素迁移 construct 失败新存储含部分迁移对象guard 清理新缓冲;旧存储是否完好取决于 move_if_noexcept 选择可拷贝或 noexcept 移动为 strong,否则退化
提交后 destroy / deallocate容器已切换至新存储依赖元素析构与释放不抛异常,完成旧存储清理必须 no-throw

关键事实

allocator_traits 的传播规则决定赋值与 swap 的异常边界:在容器拷贝赋值、移动赋值或 swap 时,若两端 allocator 不相等且不随容器传播,操作无法靠指针交换 O(1) 无异常完成,只能退化为逐元素迁移或重新分配,异常路径也从指针切换变为元素级构造与回滚。

9.6 STL 源码中的异常安全设计信号​

STL 源码通常不会在注释中直接写明“strong guarantee”,而是把异常安全设计固化为五类可观测的代码信号:

代码信号源码常见形态承担职责审查重点
临时缓冲预先 allocate 新存储或构造临时节点将可能失败的操作隔离在目标容器之外失败时目标对象是否被提前改写
guard / cleanup持有指针、alloc、构造计数、active 标记,成功路径调 release异常退栈按计数 destroy 并 deallocate是否记录构造计数,清理路径是否 no-throw
提交点指针赋值、size 更新、节点重链、swap一次性把候选状态切换为正式状态提交点内及之后是否夹杂构造、比较器或分配
类型条件noexcept(...)、is_nothrow_move_constructible、is_copy_constructible、move_if_noexcept、concepts在“可回滚的拷贝”与“移动”之间择路元素 noexcept 或拷贝删失后,强保证是否放宽
try / catch 重抛构造循环外包 try / catch,清理已构造对象后 throw;与 RAII guard 等价:本层闭合临时资源并透传异常catch 块是否漏掉 destroy 或仅做了内存释放

排查顺序

审阅 vector、string、deque、节点容器或算法源码的异常安全设计,按以下四步逐项核对:

  1. 核对接口承诺与抛出点:确认文档承诺 basic / strong / no-throw,标出所有用户构造、拷贝、移动、比较器与 allocate 调用。
  2. 定位临时区与 guard:检查可能抛出的动作是否隔离在临时缓冲内,guard 是否按已构造计数对称释放资源。
  3. 审查提交点与清理路径:确认提交前旧状态仍可访问,且提交点及之后的销毁、释放路径完全 no-throw。
  4. 用类型特征校准退化:结合元素 noexcept、拷贝可用性与 allocator 传播规则,判断强保证在极端类型下是否放宽。

最小自检任务​

动手自检先独立判断

阅读下面代码,判断 items.emplace_back(42) 在触发 std::vector<Item> 扩容时的行为:

  1. 标准库实现更可能选择移动旧元素还是拷贝旧元素?
  2. 若迁移旧元素过程中抛出异常,items 的 strong guarantee 是否稳定?说明判断步骤。
#include <vector>

struct Item {
int value{};

Item(int v) : value(v) {}
Item(const Item&) = default;
Item(Item&& other) {
value = other.value;
other.value = -1;
}
};

void append_item(std::vector<Item>& items) {
items.emplace_back(42);
}

本章知识点总结​

  • 三级异常承诺

    basic 保证对象有效且资源闭合,strong 保证失败时无副作用回滚,no-throw 保证不向外传播异常。

  • 清理路径铁律

    析构函数、deallocate 与 guard 回滚路径必须保持 no-throw,否则清理中断会直接破坏上层异常保证。

  • move_if_noexcept 择路

    仅当元素移动构造为 noexcept 或无可用拷贝构造时才返回右值引用,其余可拷贝类型退回 const T& 保住旧状态。

  • RAII guard 与计数

    guard 接管临时存储并记录已构造数量,异常退栈时仅对已构造区间调用 destroy 再 deallocate,规避未初始化析构(UB)。

  • commit / rollback 分界

    vector 扩容把分配、构造与迁移放在提交点之前,三指针更新后才解除 guard 并清理旧存储。

  • allocator 生命周期边界

    allocator_traits 分离存储管理(allocate / deallocate)与对象管理(construct / destroy),且不相等又不可传播的 allocator 会迫使赋值或 swap 退回逐元素迁移。

  • 源码审阅四步法

    先查接口承诺与抛出点,再找临时缓冲与 guard,再核对提交点后无抛出动作,最后用 noexcept 与拷贝能力校准退化边界。