在 C++ 中，try-catch 异常处理机制与资源管理（如内存、文件句柄、网络连接等）结合时，核心目标是确保无论是否发生异常，资源都能被安全释放，且程序状态保持一致。以下是资源管理和异常安全的最佳实践：

一、核心原则：依赖 RAII 管理资源（资源获取即初始化）

RAII（Resource Acquisition Is Initialization）是 C++ 中处理资源的基石，其核心思想是：将资源的生命周期与对象的生命周期绑定——通过对象的构造函数获取资源，析构函数释放资源。
当异常发生时，程序会自动触发“栈展开”（Stack Unwinding），销毁 try 块内创建的所有局部对象，从而通过析构函数自动释放资源，避免泄漏。

具体实践：

1. 用 RAII 封装所有资源
   无论是动态内存、文件句柄、锁还是网络连接，都应封装到类中，在析构函数中释放资源。

   #include <fstream>
   #include <stdexcept>
   
   // RAII 封装文件资源
   class FileHandler {
   private:
       std::ofstream file_; // 标准库文件流本身就是 RAII 实现
   public:
       // 构造函数获取资源（打开文件）
       FileHandler(const std::string& filename) : file_(filename) {
           if (!file_.is_open()) {
               throw std::runtime_error("无法打开文件: " + filename);
           }
       }
       // 析构函数自动释放资源（关闭文件）
       ~FileHandler() {
           // 无需手动 close()，ofstream 析构函数会自动处理
       }
       // 提供操作资源的接口
       void write(const std::string& content) {
           if (!file_.write(content.c_str(), content.size())) {
               throw std::runtime_error("文件写入失败");
           }
       }
   };
   
   // 使用 RAII 类，无需手动管理资源
   void writeToFile(const std::string& filename) {
       try {
           FileHandler file(filename); // 构造时打开文件
           file.write("Hello, RAII!"); // 操作资源
           // 若此处抛出异常，file 的析构函数会自动调用，关闭文件
       } catch (const std::exception& e) {
           std::cerr << "错误: " << e.what() << std::endl;
       }
   }
   

2. 优先使用标准库的 RAII 工具
   标准库已为常见资源提供了 RAII 封装，应优先使用而非手动管理：

   • 动态内存：用 std::unique_ptr/std::shared_ptr 替代裸指针（new/delete）。
   • 文件：std::ifstream/std::ofstream 自动管理文件句柄。
   • 锁：std::lock_guard/std::unique_lock 自动管理互斥锁（避免死锁）。

   #include <memory> // 智能指针
   
   void useDynamicMemory() {
       try {
           // unique_ptr 析构时自动释放内存，无需手动 delete
           std::unique_ptr<int[]> arr(new int[100]); 
           // 若此处抛出异常，arr 会自动销毁并释放内存
           arr[0] = 42;
       } catch (...) {
           // 无需处理内存释放，RAII 已保证
       }
   }
   

二、异常安全的三个级别（从低到高）

异常安全（Exception Safety）指函数在抛出异常后，程序状态的一致性和资源安全性。需根据场景选择合适的安全级别：

1. 基本保证（Basic Guarantee）

• 要求：异常发生后，所有资源已释放，对象处于有效但不确定的状态（即对象的 invariants 仍成立，可安全销毁或调用成员函数）。

• 适用场景：大多数普通函数，如简单的 setter 方法。

  class Buffer {
   private:
       std::unique_ptr<char[]> data_;
       size_t size_ = 0;
   public:
       // 基本保证：异常后 data_ 仍有效，size_ 可能变化但对象可安全使用
       void resize(size_t new_size) {
           // 先分配新内存（若失败，原数据不变）
           auto new_data = std::make_unique<char[]>(new_size);
           // 拷贝旧数据（若抛出异常，new_data 会自动释放，原数据仍在）
           std::copy(data_.get(), data_.get() + std::min(size_, new_size), new_data.get());
           // 交换资源（无异常）
           data_.swap(new_data);
           size_ = new_size;
       }
   };
  

2. 强保证（Strong Guarantee）

• 要求：函数操作要么完全成功，要么完全不改变程序状态（仿佛从未执行过）。

• 实现技术：常用“拷贝-交换”（Copy-and-Swap）模式——先拷贝对象，在拷贝上执行操作，成功后交换拷贝与原对象。

  class SafeBuffer {
   private:
       std::unique_ptr<char[]> data_;
       size_t size_ = 0;
   public:
       // 强保证：异常后对象状态与调用前完全一致
       void safeResize(size_t new_size) {
           // 1. 拷贝当前对象状态
           SafeBuffer temp(*this); 
           // 2. 在拷贝上执行修改（若异常，原对象不受影响）
           temp.data_ = std::make_unique<char[]>(new_size);
           std::copy(data_.get(), data_.get() + std::min(size_, new_size), temp.data_.get());
           temp.size_ = new_size;
           // 3. 交换拷贝与原对象（无异常操作）
           swap(temp); 
       }
       // 交换函数（无异常）
       void swap(SafeBuffer& other) noexcept {
           data_.swap(other.data_);
           std::swap(size_, other.size_);
       }
   };
  

3. 不抛出保证（No-Throw Guarantee）

• 要求：函数绝对不会抛出任何异常，任何可能的错误都在内部处理。

• 适用场景：析构函数、swap 函数、简单的访问器（getter）等关键函数。

  class NoThrowExample {
   private:
       int value_;
   public:
       // 析构函数必须保证不抛出（否则栈展开时可能导致程序终止）
       ~NoThrowExample() noexcept { 
           // 释放资源的操作必须确保成功（如智能指针的析构）
       }
       // swap 函数通常设计为不抛出
       void swap(NoThrowExample& other) noexcept {
           std::swap(value_, other.value_); // std::swap 对基本类型不抛出
       }
   };
  

三、关键注意事项

1. 析构函数绝对不能抛出异常

析构函数在“栈展开”（异常处理时销毁对象）过程中被调用，若此时析构函数抛出新异常，会导致双重异常，程序会立即调用 std::terminate() 终止，无法恢复。

• 若析构函数中可能发生错误，应在内部捕获并处理（如记录日志），禁止向外抛出。

  class SafeDestructor {
   public:
       ~SafeDestructor() noexcept { // 显式声明不抛出
           try {
               // 可能出错的操作（如关闭网络连接）
               closeConnection(); 
           } catch (...) {
               // 内部处理错误（如记录日志），不向外抛出
               logError("关闭连接失败");
           }
       }
   };
  

2. 构造函数中获取资源的异常处理

若构造函数抛出异常，对象的析构函数不会被调用。因此，构造函数中若获取了多个资源，需确保：

• 先获取的资源在后续资源获取失败时能被正确释放。

• 优先使用 RAII 子对象管理资源（子对象的析构函数会在构造函数异常时被调用）。

  class ResourceHolder {
   private:
       std::unique_ptr<ResourceA> a_; // RAII 管理资源A
       std::unique_ptr<ResourceB> b_; // RAII 管理资源B
   public:
       ResourceHolder() 
           : a_(new ResourceA()), // 先获取资源A
             b_(new ResourceB())  // 再获取资源B（若失败，a_ 的析构会释放资源A）
       {}
   };
  

3. 避免在 catch 块中遗漏资源释放

若必须使用裸资源（不推荐），catch 块中需手动释放已获取的资源，且需注意释放顺序（与获取顺序相反）。

void riskyOperation() {
    FILE* file = nullptr;
    int* buffer = nullptr;
    try {
        file = fopen("data.txt", "r"); // 获取资源1
        if (!file) throw std::runtime_error("文件打开失败");
        
        buffer = new int[100]; // 获取资源2
        // ... 操作资源 ...
    } catch (...) {
        // 释放已获取的资源（与获取顺序相反）
        delete[] buffer; 
        if (file) fclose(file);
        throw; // 重新抛出异常
    }
    // 正常路径释放资源
    delete[] buffer;
    fclose(file);
}

4. 用 noexcept 明确异常规格

通过 noexcept 声明函数是否可能抛出异常，帮助编译器优化，并让调用者明确是否需要处理异常：

• 对提供“不抛出保证”的函数（如析构函数、swap），显式声明 noexcept。

• 对可能抛出异常的函数，可省略（默认 noexcept(false)）。

  void noThrowFunc() noexcept {
      // 操作保证不抛出异常
  }
  
  void mayThrowFunc() { // 隐含 noexcept(false)
      // 可能抛出异常
  }
  

总结

资源管理和异常安全的核心是依赖 RAII 自动管理资源，辅以明确的异常安全级别设计。实践中应：

1. 用 RAII 类（如智能指针、标准库容器）封装所有资源，避免裸资源操作；
2. 确保析构函数不抛出异常，关键函数提供“不抛出保证”；
3. 对需要强一致性的操作，采用“拷贝-交换”模式实现强保证；
4. 避免手动释放资源，若必须手动操作，需在 catch 块中严格处理释放逻辑。

遵循这些原则可有效避免资源泄漏，确保程序在异常发生后仍能安全、一致地运行。