C++异常安全编程：RAII与三级保证实践指南

1. C++异常安全的核心挑战

在C++开发中，异常安全是一个经常被忽视却又至关重要的话题。当异常被抛出时，程序的控制流会发生非线性的跳转，这可能导致资源泄漏、数据不一致等问题。我曾在一个大型金融交易系统中遇到过这样的案例：由于异常处理不当，导致内存泄漏累积，系统运行三天后就会因内存耗尽而崩溃。

异常安全的核心在于保证当异常发生时：

• 已申请的资源能够被正确释放
• 对象状态保持一致性
• 数据结构不被破坏

2. 异常安全的三级保证

2.1 基本保证（Basic Guarantee）

这是最基础的异常安全级别，它确保：

• 不会发生资源泄漏
• 所有对象处于有效状态（即使不是预期的状态）

实现要点：

1. 使用RAII管理所有资源
2. 在修改对象状态前先完成可能抛出异常的操作
3. 确保操作要么完全成功，要么回滚到操作前的状态

cpp复制class DatabaseConnection {
    Connection* conn;
public:
    void updateRecord(int id, const string& data) {
        Connection* newConn = establishNewConnection(); // 可能抛出异常
        delete conn;      // 不会抛出异常
        conn = newConn;   // 原子操作
        // ...执行更新操作
    }
};

2.2 强保证（Strong Guarantee）

这一级别保证操作要么完全成功，要么程序状态保持不变，就像操作从未发生过一样。实现方法包括：

1. 拷贝-交换模式（Copy-Swap）
2. 事务性操作
3. 在修改前完成所有可能抛出异常的工作

cpp复制class ConfigManager {
    map<string, string> config;
    
    void updateConfig(const string& key, const string& value) {
        auto temp = config;          // 拷贝
        temp[key] = value;           // 修改拷贝
        std::swap(config, temp);     // 原子交换
    }
};

2.3 无抛出保证（No-throw Guarantee）

最高级别的保证，承诺操作绝不会抛出异常。适用于：

1. 析构函数
2. 简单的getter方法
3. 内存释放操作

实现技巧：

• 使用noexcept声明
• 避免任何可能抛出异常的操作
• 对于不可避免的操作，使用try-catch内部消化

cpp复制class SimpleBuffer {
    char* buffer;
public:
    ~SimpleBuffer() noexcept {
        delete[] buffer; // delete[] 不会抛出异常
    }
};

3. RAII：异常安全的基石

资源获取即初始化（RAII）是C++管理资源的黄金法则。其核心思想是将资源生命周期与对象生命周期绑定。

3.1 智能指针的应用

cpp复制void processFile() {
    // 传统方式（不安全）
    FILE* f = fopen("data.txt", "r");
    // ...如果这里抛出异常，文件句柄泄漏
    fclose(f);

    // RAII方式（安全）
    std::unique_ptr<FILE, decltype(&fclose)> 
        f2(fopen("data.txt", "r"), &fclose);
    // 即使抛出异常，文件也会被正确关闭
}

3.2 自定义RAII包装器

对于非标准资源，可以创建自定义RAII类：

cpp复制class MutexLock {
    std::mutex& mtx;
public:
    explicit MutexLock(std::mutex& m) : mtx(m) { mtx.lock(); }
    ~MutexLock() { mtx.unlock(); }
    // 禁止拷贝
    MutexLock(const MutexLock&) = delete;
    MutexLock& operator=(const MutexLock&) = delete;
};

void criticalSection() {
    static std::mutex m;
    MutexLock lock(m);  // 自动上锁
    // ...操作共享资源
    // 离开作用域时自动解锁
}

4. 异常安全的设计模式

4.1 拷贝-交换惯用法

这是实现强保证的经典模式：

cpp复制class Widget {
    struct Impl;
    std::unique_ptr<Impl> pImpl;
public:
    void swap(Widget& other) noexcept {
        using std::swap;
        swap(pImpl, other.pImpl);
    }
    
    Widget& operator=(const Widget& rhs) {
        Widget temp(rhs);  // 拷贝构造可能抛出异常
        swap(temp);        // 不会抛出
        return *this;
        // temp离开作用域，自动清理旧资源
    }
};

4.2 事务性更新

对于需要多个步骤的操作，可以先在临时对象上完成所有工作，最后提交：

cpp复制class Document {
    vector<Paragraph> paragraphs;
public:
    void appendParagraphs(const vector<Paragraph>& newParas) {
        vector<Paragraph> temp = paragraphs;  // 拷贝
        temp.insert(temp.end(), newParas.begin(), newParas.end());  // 修改
        paragraphs.swap