C++ 第四阶段 异常处理 - 第二节：异常安全编程

目录

一、异常安全性的核心概念

二、异常安全性的三个级别

三、异常安全编程的核心原则

四、多线程环境下的异常安全

五、异常安全的常见陷阱与解决方案

六、异常安全代码设计示例

1. 基本异常安全：资源释放

2. 强异常安全：复制-交换

3. 无异常抛出：noexcept 保证

七、调试与验证工具

八、总结

C++从入门到入土学习导航_c++学习进程-CSDN博客

一、异常安全性的核心概念

异常安全性（Exception Safety）是指在程序发生异常时，能够确保：

1. 资源正确释放（如内存、文件句柄、锁等）。
2. 数据一致性（对象状态不会部分修改或损坏）。
3. 程序行为可预测（不会崩溃或进入不可恢复状态）。

二、异常安全性的三个级别

C++ 异常安全性通常分为以下三个级别：

三、异常安全编程的核心原则

1. RAII（Resource Acquisition Is Initialization）

   • 通过对象的构造函数获取资源，在析构函数中释放资源，确保异常发生时资源自动回收。

   class FileHandler {
   public:
       FileHandler(const std::string& filename) {
           file_ = fopen(filename.c_str(), "r");
           if (!file_) throw std::runtime_error("无法打开文件");
       }
       ~FileHandler() { fclose(file_); }  // 异常时自动关闭文件
   private:
       FILE* file_;
   };

2. 避免手动资源管理

   • 使用智能指针（如 std::unique_ptr、std::shared_ptr）或标准库容器（如 std::vector）自动管理资源。

   void safeFunction() {
       std::unique_ptr<int> ptr = std::make_unique<int>(10);
       // 即使抛出异常，ptr 也会自动释放
   }

3. 捕获并处理所有异常

   • 在顶层（如 main 函数）使用 catch(...) 捕获所有未处理的异常，防止程序崩溃。

   int main() {
       try {
           riskyFunction();
       } catch (const std::exception& e) {
           std::cerr << "异常: " << e.what() << std::endl;
       } catch (...) {
           std::cerr << "未知异常" << std::endl;
       }
       return 0;
   }

4. 强异常安全：事务式操作

   • 使用 copy-and-swap 惯用法确保操作的原子性（强保证）。

   class Container {
   public:
       void push_back(int value) {
           std::vector<int> temp = data_;  // 备份当前数据
           temp.push_back(value);          // 修改临时副本
           data_.swap(temp);               // 交换数据（原子操作）
       }
   private:
       std::vector<int> data_;
   };

5. 避免异常传播到析构函数

   • 析构函数应始终提供 noexcept 保证，否则可能导致 std::terminate 被调用。

   class Resource {
   public:
       ~Resource() noexcept { /* 安全释放资源 */ }
   };

四、多线程环境下的异常安全

在并发编程中，异常安全要求更高：

1. 锁的自动释放

   • 使用 std::lock_guard 或 std::unique_lock 管理锁，避免死锁。

   std::mutex mtx;
   void threadSafeFunction() {
       std::lock_guard<std::mutex> lock(mtx);
       // 即使抛出异常，锁会自动释放
   }

2. 同步操作的原子性

   • 在共享资源修改时，确保操作的原子性（如使用 std::atomic 或事务性内存）。

   std::atomic<int> counter(0);
   void increment() {
       ++counter;  // 原子操作，无异常风险
   }

3. 异常传播与线程终止

   • 在线程中捕获异常，避免异常传播到主线程导致程序崩溃。

   std::thread t([]() {
       try {
           // 可能抛出异常的代码
       } catch (...) {
           std::cerr << "线程异常被捕获" << std::endl;
       }
   });
   t.join();

五、异常安全的常见陷阱与解决方案

六、异常安全代码设计示例

1. 基本异常安全：资源释放

class DatabaseConnection {
public:
    DatabaseConnection() {
        connection_ = connectToDB();  // 可能抛出异常
    }
    ~DatabaseConnection() {
        if (connection_) disconnect(connection_);  // 确保连接关闭
    }
    void query(const std::string& sql) {
        executeQuery(connection_, sql);  // 可能抛出异常
    }
private:
    DBHandle connection_;
};

2. 强异常安全：复制-交换

class StringList {
public:
    void add(const std::string& str) {
        std::vector<std::string> temp = data_;  // 备份数据
        temp.push_back(str);                    // 修改临时副本
        data_.swap(temp);                       // 原子交换
    }
private:
    std::vector<std::string> data_;
};

3. 无异常抛出：noexcept 保证

class NoExceptExample {
public:
    void safeMethod() noexcept {
        // 不抛出异常的操作
    }
    ~NoExceptExample() noexcept {
        // 析构函数无异常
    }
};

七、调试与验证工具

1. Valgrind

   • 检测内存泄漏和异常导致的未释放资源。

   valgrind --leak-check=full ./your_program

2. AddressSanitizer

   • 编译时启用，检测运行时异常和内存错误。

   g++ -fsanitize=address -g your_program.cpp -o your_program

3. 静态分析工具

   • 使用 Clang Static Analyzer 或 Cppcheck 检查潜在异常安全问题。

   clang-tidy your_program.cpp --checks=-*,clang-analyzer-*

八、总结

异常安全编程是 C++ 开发中不可或缺的技能。通过遵循以下原则，可以显著提高代码的健壮性和可靠性：

1. 优先使用 RAII 和智能指针 管理资源。
2. 提供明确的异常安全保证（基本、强或无异常抛出）。
3. 在顶层捕获所有异常，防止程序崩溃。
4. 在并发环境中，使用锁管理器和原子操作确保线程安全。
5. 定期使用调试工具 验证异常安全性和资源管理。