C++ 异常安全保证：基本、强与无抛异常

在 C++ 开发中，异常机制是处理错误的重要手段。然而，当异常抛出时，程序的状态是否仍然可控？资源是否会泄露？数据结构是否会遭到破坏？这些问题构成了异常安全的核心关切。

什么是异常安全

异常安全是指：当异常抛出时，程序能够保持确定性的状态，不会陷入未定义行为或资源泄露的困境。简单来说，异常安全保证回答了一个关键问题——"如果中途出错，我的程序还能好好收场吗？"

考虑一个简单的文件操作场景：

void saveReport(Report& report) {
    disk.write(report.getData(), report.getSize());  // 可能抛出 IOError
    database.insert(report);                           // 可能抛出 DatabaseError
    notification.send(report);                         // 可能抛出 NetworkError
}

如果 database.insert 抛出异常，前面已经完成的 disk.write 操作是否应该回滚？如果不处理这个问题，程序将处于不一致状态——文件已写入，但数据库没有记录。

三种异常安全级别

C++ 异常安全分为三个层次，每个层次对应不同的保障能力。

基本保证：守住底线

基本保证是异常安全的底线，确保两件事：第一，不会泄漏资源；第二，对象仍然可用。

class Widget {
    Resource* resource;
public:
    Widget() : resource(nullptr) {
        resource = new Resource();  // 可能抛出 std::bad_alloc
    }

    ~Widget() {
        delete resource;  // RAII 确保资源释放
    }

    void doSomething() {
        resource->process();  // 可能抛出 ResourceError
    }
};

上述代码通过 RAII（Resource Acquisition Is Initialization）模式保证了基本异常安全。即使 process() 抛出异常，Widget 对象的析构函数仍会正确执行，不会发生内存泄漏。

关键点：基本保证不要求操作"完全成功"或"完全失败"，只要求系统处于有效状态。

强保证：要么全成，要么全败

强保证也称为事务语义——操作具有原子性。失败时，系统状态完全恢复到操作之前，如同什么都没发生过。

实现强保证的经典手法是复制-交换（Copy-and-Swap）：

class Transaction {
    AccountData* data;

    // 在临时对象上执行操作
    Transaction doOperations(const Transaction& original) const {
        Transaction temp(original);  // 复制原始状态
        temp.operationA();            // 可能抛出
        temp.operationB();            // 可能抛出
        return temp;                  // 返回新状态
    }

public:
    void execute() {
        Transaction newState = doOperations(*this);
        data->swap(newState);         // swap 绝不抛出异常
    }
};

工作原理：

1. 复制当前状态到临时对象
2. 在临时对象上执行所有可能抛出的操作
3. 如果全部成功，使用 swap 原子性地替换原状态
4. 如果某步抛出异常，原对象毫发无损

强保证的代价是性能开销——复制整个状态需要额外的时间和内存。只有在业务逻辑确实需要"原子性"时才应采用。

无抛异常保证：承诺永不抛出

无抛异常保证（No-throw Guarantee）是最严格的级别，函数必须保证永不抛出异常。任何可能的异常都必须在函数内部捕获并处理。

标准库中的 swap 函数是典型代表：

template<typename T>
void swap(T& a, T& b) noexcept {
    T tmp(std::move(a));
    a = std::move(b);
    b = std::move(tmp);
}

必须实现为无抛异常的函数：

使用 noexcept 关键字声明这类函数：

class CriticalSection {
    std::mutex mutex;
public:
    ~CriticalSection() noexcept {
        // 绝不能抛出异常
        // 如果 mutex.unlock() 失败，程序无法继续
    }

    // 移动构造函数也应当是无抛异常
    CriticalSection(CriticalSection&&) noexcept = default;
};

如何选择异常安全级别

选择异常安全级别需要权衡业务需求、性能开销和实现复杂度。

按场景选择

常见误区

过度追求强保证：不是所有操作都需要强保证。强制对简单操作实现强保证会导致不必要的性能开销。例如，给一个 vector 添加元素时，如果内存分配失败，vector 会保持有效状态，此时基本保证已经足够。

忽视析构函数异常：C++11 之前，析构函数默认可能抛出异常。从 C++11 起，析构函数隐式 noexcept，从析构函数抛出异常会导致 std::terminate 被调用。这意味着析构函数内的所有操作都必须安全完成。

实用技巧与最佳实践

使用 RAII 管理资源

RAII 是异常安全的基石。资源获取即初始化，资源释放绑定于对象析构：

class FileHandle {
    std::FILE* file;
public:
    explicit FileHandle(const char* path) 
        : file(std::fopen(path, "r")) {
        if (!file) throw std::runtime_error("Cannot open file");
    }

    ~FileHandle() {
        if (file) std::fclose(file);
    }

    std::string readLine() {
        char buffer[256];
        if (std::fgets(buffer, sizeof(buffer), file)) {
            return buffer;
        }
        return "";
    }
};

优先使用标准智能指针

std::unique_ptr 和 std::shared_ptr 自动管理内存，消除了手动 delete 带来的泄漏风险：

void processData() {
    auto data = std::make_unique<Data>();  // 异常安全
    data->parse(input);
    data->validate();

    // 任何步骤抛出异常，data 都会自动释放
}

谨慎使用原始指针和引用

从函数返回的原始指针或引用可能在异常发生时成为悬空引用：

// 危险写法
Widget* createWidget() {
    Widget* w = new Widget();
    w->initialize();  // 可能抛出异常
    return w;         // 如果 initialize 抛出，调用者无法删除 w
}

// 安全写法
std::unique_ptr<Widget> createWidget() {
    auto w = std::make_unique<Widget>();
    w->initialize();
    return w;
}

明确标注异常规格

使用 noexcept 明确标注函数是否会抛出异常：

// 明确表示此函数不会抛出
void commitTransaction() noexcept {
    // 实现细节也必须保证不抛异常
}

// 表示此函数可能抛出
void parseDocument() throws(std::runtime_error) {
    // ...
}

总结

异常安全是 C++ 程序员必须掌握的核心技能。基本保证守住底线，强保证提供原子性语义，无抛异常保证作为底层支撑。选择合适的保证级别，需要在安全性、性能和复杂度之间找到平衡点。

核心原则：让资源管理自动化（RAII），让状态变更原子化（复制-交换），让基础操作稳健化（noexcept）。遵循这些原则，程序在面对异常时将始终保持可控和优雅。