cpp

C++ 异常安全与错误处理策略：noexcept、RAII 与 Herb Sutter 指引

C++ 异常机制是资源管理与错误传播的核心基础设施，但异常安全等级、noexcept 语义、异常开销与替代方案（std::expected）的权衡，往往让开发者感到困惑。本文从异常安全保证等级出发，系统梳理 noexcept 传播规则、Herb Sutter 的异常使用原则，以及 C++23 std::expected 作为无异常错误处理的新范式，帮助你在工程中做出正确的选择。

Leeting Yan 7 分钟阅读 3353 字

C++ 的异常机制自诞生起就充满争议。一方面，异常允许错误信息沿调用栈自动传播，将正常逻辑与错误处理解耦；另一方面，异常带来的运行时开销、对实时系统的干扰以及异常安全代码的编写难度，使许多项目选择 -fno-exceptions 彻底关闭异常。理解异常安全保证等级、noexcept 语义与替代方案，是编写健壮 C++ 代码的必修课。

一、异常安全保证等级

异常安全（Exception Safety）描述的是：当函数抛出异常时，程序状态保持何种程度的完好。C++ 标准定义了三个基本等级，由弱到强排列。

1.1 基本保证（Basic Guarantee）

基本保证承诺：如果发生异常，程序不会泄露资源，不会访问已释放内存，所有对象保持有效（但具体内容可能改变）。这是绝大多数函数应达到的底线。

实现基本保证的核心策略是RAII。当异常抛出时，栈会按构造的逆序自动析构局部对象，释放它们持有的资源：

#include <vector>
#include <memory>

class DataProcessor {
    std::vector<int> buffer_;
    std::unique_ptr<FileHandle> file_;
public:
    void process() {
        buffer_.reserve(1024);        // 可能抛出
        file_->read_into(buffer_);    // 可能抛出
        buffer_.push_back(42);        // 强保证（vector push_back 本身）
    }
};

上述代码中，即使 read_into 抛出异常，buffer_ 和 file_ 会通过自动析构完成清理，不会泄露文件句柄。这就是 RAII 在异常安全中的基础价值——见 https://plumephp.com/cpp-memory-model/ 对 RAII 哲学的深入讨论。

1.2 强保证（Strong Guarantee）

强保证承诺：如果发生异常，程序状态会回滚到函数调用之前。即操作要么完全成功，要么完全不产生任何副作用。这对于事务性操作至关重要。

实现强保证的经典手法是copy-and-swap：

#include <vector>
#include <algorithm>

class Widget {
    std::vector<int> data_;
public:
    void update(const std::vector<int>& new_data) {
        // 1. 在临时对象上完成所有可能失败的操作
        std::vector<int> temp = data_;
        temp.insert(temp.end(), new_data.begin(), new_data.end());
        std::sort(temp.begin(), temp.end());  // 可能抛出比较操作异常
        
        // 2. 只有成功到达此处，才提交状态
        data_.swap(temp);  // swap 不抛异常（noexcept）
    }
};

std::vector::swap 在标准中被保证不抛出异常，因此如果排序过程中抛出，原始 data_ 不受影响，状态回滚得以实现。

1.3 不抛保证（No-throw Guarantee）

不抛保证承诺：函数绝不抛出异常。这是最强的保证，也是实现强保证的基石——swap 和析构函数必须满足不抛保证，否则强保证的回滚机制会崩溃。

C++11 引入的 noexcept 关键字让不抛保证从文档约定变为编译器可验证的契约。

二、noexcept 语义与传播规则

2.1 noexcept 的基本用法

noexcept 可以作为一个说明符（specifier）出现在函数声明后：

void safe_swap(int& a, int& b) noexcept {
    int tmp = a;
    a = b;
    b = tmp;
}

编译器基于 noexcept 可以做两件事：

  1. 优化机会：如果调用链中所有函数都标记 noexcept，编译器无需生成异常处理的栈展开代码（unwind table），减少二进制体积；
  2. 契约保证：如果 noexcept 函数内部抛出了未捕获的异常，std::terminate() 会被立即调用，程序异常终止。

2.2 条件 noexcept

noexcept 还可以接受一个布尔表达式，即条件 noexcept，这在泛型代码中极为重要：

#include <type_traits>
#include <vector>

template <typename T>
void safe_swap(T& a, T& b) noexcept(std::is_nothrow_swappable_v<T>) {
    using std::swap;
    swap(a, b);
}

// 检查 vector<int> 的 swap 是否 noexcept
static_assert(noexcept(safe_swap(std::declval<std::vector<int>&>(),
                                 std::declval<std::vector<int>&>())));

std::vector::swap 的 noexcept 性质取决于其元素类型是否满足 noexcept 可交换。条件 noexcept 让编译器能够在实例化时精确推导这种传播链——这是 https://plumephp.com/cpp-templates-generics/ 中类型萃取（Type Traits）的典型应用。

2.3 为什么析构函数隐式 noexcept

C++11 起，编译器自动为所有析构函数生成隐式的 noexcept(true)，除非：

  • 析构函数显式声明为 noexcept(false)；
  • 或基类 / 成员变量的析构函数声明为 noexcept(false)。

析构函数抛出异常是绝对禁止的。如果在栈展开过程中析构函数抛出异常，会导致 std::terminate()。这是因为栈展开已经在处理一个异常了，无法同时处理第二个。

2.4 noexcept 与移动语义

noexcept 对移动语义有决定性影响。std::vector 在重新分配内存时，如果元素的移动构造函数标记 noexcept，它会选择移动元素；否则降级为复制：

#include <iostream>
#include <vector>

struct SafeMove {
    int* data;
    SafeMove() : data(new int[1000]) {}
    ~SafeMove() { delete[] data; }
    
    // noexcept 移动构造
    SafeMove(SafeMove&& other) noexcept
        : data(other.data) { other.data = nullptr; }
    
    SafeMove(const SafeMove& other)
        : data(new int[1000]) {
        std::copy(other.data, other.data + 1000, data);
    }
};

struct UnsafeMove {
    int* data;
    UnsafeMove() : data(new int[1000]) {}
    ~UnsafeMove() { delete[] data; }
    
    // 不标记 noexcept 的移动构造
    UnsafeMove(UnsafeMove&& other)
        : data(other.data) { other.data = nullptr; }
    
    UnsafeMove(const UnsafeMove& other)
        : data(new int[1000]) {
        std::copy(other.data, other.data + 1000, data);
    }
};

int main() {
    std::vector<SafeMove> safe(100);
    safe.reserve(200);
    safe.emplace_back();  // 触发重分配时，SafeMove 会移动（快）
    
    std::vector<UnsafeMove> unsafe(100);
    unsafe.reserve(200);
    unsafe.emplace_back();  // 触发重分配时，UnsafeMove 被复制（慢 1000 倍）
    return 0;
}

经验法则：自定义的移动构造函数和移动赋值运算符，只要内部不会抛出，务必标记 noexcept。

三、异常处理的开销真相

关于异常的性能代价存在大量误解。真相是：

  • 正常路径（不抛异常时）：现代编译器实现零运行时开销。异常处理表（LSDA）放在二进制特殊段中，只在异常实际抛出时被查询；
  • 异常抛出路径：代价极高。需要遍历栈帧、查找 catch 匹配、执行栈展开和析构。统计上可能比返回错误码慢 2-3 个数量级；
  • 二进制体积：每个函数都需要生成 unwind 信息，对于 -fno-exceptions 的嵌入式项目，这可以节省可观的代码段空间。

因此，异常最适合处理真正异常、罕见、无法本地恢复的错误——例如文件系统损坏、网络连接完全断开、内存分配失败。对于频繁发生的错误（如解析失败、验证不通过），应以返回值或 std::expected 传递。

四、Herb Sutter 的异常使用原则

C++ 专家 Herb Sutter 在多篇 GotW（Guru of the Week）和演讲中系统阐述了异常使用哲学，可归纳为以下几条核心原则：

  1. 使用异常报告意外错误：如果错误是调用方的 bug（如前置条件违反），用 assert；如果错误是外部条件引起且调用方通常无法预防，用异常；
  2. 绝不在析构函数中抛出：前面已经强调；
  3. 按值抛出，按引用捕获：抛出派生类异常时，按引用捕获避免对象切片；
  4. 保持异常类的继承层次扁平：不要滥用深层继承，标准库异常层次（exception -> runtime_error / logic_error）已足够；
  5. 异常信息应包含足够的诊断上下文：在重新抛出前，可以附加上下文信息，但不要吞掉原始异常。
try {
    parse_config("app.toml");
} catch (const std::exception& e) {
    // 保留原始异常，添加上下文，重新抛出
    std::throw_with_nested(
        std::runtime_error("Failed to initialize application configuration"));
}

std::throw_with_nested 和 std::rethrow_if_nested 在 C++11 中引入，可构建异常链用于深层错误诊断。

五、std::expected：C++23 的无异常错误处理

C++23 正式将 std::expected<T, E> 纳入标准，提供了一种介于异常和原始错误码之间的优雅方案。expected 要么包含一个值 T，要么包含一个错误 E，全程无异常：

#include <expected>
#include <string>
#include <fstream>
#include <iostream>

enum class FileError {
    NotFound,
    PermissionDenied,
    TooLarge
};

std::expected<std::string, FileError> read_config(const std::string& path) {
    std::ifstream file(path);
    if (!file) {
        return std::unexpected(FileError::NotFound);
    }
    
    file.seekg(0, std::ios::end);
    auto size = file.tellg();
    if (size > 1024 * 1024) {
        return std::unexpected(FileError::TooLarge);
    }
    
    file.seekg(0, std::ios::beg);
    return std::string{std::istreambuf_iterator<char>(file), {}};
}

int main() {
    auto result = read_config("config.ini");
    
    // 方法 1：显式检查
    if (result.has_value()) {
        std::cout << "Config: " << result.value() << std::endl;
    } else {
        std::cout << "Error code: " << static_cast<int>(result.error()) << std::endl;
    }
    
    // 方法 2：函数式链式调用（C++23）
    auto processed = read_config("config.ini")
        .and_then([](const std::string& content) -> std::expected<int, FileError> {
            if (content.empty()) return std::unexpected(FileError::NotFound);
            return static_cast<int>(content.size());
        })
        .or_else([](FileError err) -> std::expected<int, FileError> {
            std::cerr << "File operation failed" << std::endl;
            return std::unexpected(err);
        });
    
    return 0;
}

std::expected 的设计直接借鉴了 Rust 的 Result<T, E> 和 Haskell 的 Either，配合 Ranges 风格的 and_then / or_else / transform 方法链，让错误处理变得显式且可组合。

六、错误码 vs 异常 vs 返回值的选型决策

策略适用场景优点缺点
返回值 + out 参数C 风格 API、简单场景零开销、跨语言友好容易忽略返回值，错误传递繁琐
异常罕见错误、构造函数失败、深层调用栈自动传播、强制处理、与正常逻辑解耦运行时开销大、RTTI 依赖、实时系统禁用
std::expected高频错误、明确的成功/失败语义显式传播、零异常开销、函数式组合需要 C++23、调用链代码量增加
std::optional值可能不存在，无具体错误码轻量、C++17 可用无法携带错误信息

选择指南：

  • 构造函数和运算符重载中无法返回错误码，优先用异常；
  • 高频操作（如字符串解析、网络包解码）使用 std::expected 或 std::optional；
  • 嵌入式、实时系统、游戏主循环等 -fno-exceptions 场景，禁用异常，使用错误码 + std::expected 的 polyfill；
  • 跨语言绑定接口（如 C API）不使用异常，用返回码。

相关阅读

  • https://plumephp.com/cpp-memory-model/ — 深入理解 RAII 设计哲学与对象生命周期管理
  • https://plumephp.com/cpp-modern-17-20-23/ — std::optional、std::variant 与 std::expected 的类型安全容器家族
  • https://plumephp.com/cpp-concurrency-patterns/ — 并发环境下异常安全与 std::future 的异常传播机制

延伸阅读

  • 同步原语：信号量、互斥锁、条件变量与读写锁 — 操作系统层面的错误传播与信号机制
  • https://plumephp.com/posts/rust/ — Rust 的 Result 与 ? 运算符，与 C++23 std::expected 的设计对比
  • https://plumephp.com/posts/cs-fundamentals/ — 编译器对异常处理的栈展开实现原理

文末完整示例

// 完整可运行示例： noexcept 传播 + 强异常安全 + std::expected
// 编译：g++ -std=c++23 -o exception_demo exception_demo.cpp

#include <expected>
#include <iostream>
#include <vector>
#include <string>
#include <stdexcept>
#include <type_traits>

enum class ParseError {
    EmptyInput,
    InvalidFormat,
    Overflow
};

std::expected<int, ParseError> safe_parse(const std::string& s) noexcept {
    if (s.empty()) {
        return std::unexpected(ParseError::EmptyInput);
    }
    try {
        size_t pos = 0;
        int value = std::stoi(s, &pos);
        if (pos != s.size()) {
            return std::unexpected(ParseError::InvalidFormat);
        }
        return value;
    } catch (const std::out_of_range&) {
        return std::unexpected(ParseError::Overflow);
    } catch (const std::invalid_argument&) {
        return std::unexpected(ParseError::InvalidFormat);
    }
}

class SafeBuffer {
    std::vector<int> data_;
public:
    SafeBuffer() = default;
    SafeBuffer(const SafeBuffer&) = default;
    SafeBuffer(SafeBuffer&& other) noexcept
        : data_(std::move(other.data_)) {}
    SafeBuffer& operator=(SafeBuffer&& other) noexcept {
        if (this != &other) {
            data_ = std::move(other.data_);
        }
        return *this;
    }

    // 强异常安全保证：copy-and-swap
    void append_sorted(const std::vector<int>& values) {
        std::vector<int> temp = data_;
        temp.insert(temp.end(), values.begin(), values.end());
        std::sort(temp.begin(), temp.end());
        data_.swap(temp);  // noexcept
    }

    const std::vector<int>& data() const noexcept { return data_; }
};

int main() {
    // 测试 std::expected
    auto r1 = safe_parse("42");
    std::cout << "Parse '42': " << (r1.has_value() ? std::to_string(r1.value()) : "error") << std::endl;

    auto r2 = safe_parse("not_a_number");
    std::cout << "Parse invalid: " << (r2.has_value() ? "ok" : "failed") << std::endl;

    // 测试 noexcept 传播
    static_assert(noexcept(SafeBuffer(std::declval<SafeBuffer>())));

    // 测试强异常安全
    SafeBuffer buf;
    buf.append_sorted({3, 1, 4});
    buf.append_sorted({1, 5, 9});
    std::cout << "Buffer: ";
    for (int v : buf.data()) std::cout << v << " ";
    std::cout << std::endl;

    return 0;
}

继续阅读

探索更多技术文章

浏览归档，发现更多关于系统设计、工具链和工程实践的内容。

全部文章 返回首页

「cpp」更多文章

  1. C++20 Modules 模块化与构建系统演进
  2. C++20 Ranges 与惰性求值视图
  3. C++ 单元测试框架：Google Test、Catch2、Doctest 与 Mock 技巧