C++ RAII机制

RAII（Resource Acquisition Is Initialization）是一种编程范式，核心思想是：资源的生命周期与对象绑定——对象创建时获取资源，对象销毁时自动释放资源。这种机制通过构造函数和析构函数的配对执行，确保资源管理的安全性和一致性。

RAII 的核心原则

1. 资源获取即初始化：在对象的构造函数中获取资源（如内存、文件句柄、网络连接等）。
2. 资源释放即析构：在对象的析构函数中释放资源，确保资源被正确回收。

典型应用场景

1. 智能指针（C++）

通过 RAII 管理动态分配的内存，避免内存泄漏。

#include <memory>

// std::unique_ptr 独占资源所有权
{
    std::unique_ptr<int> ptr = std::make_unique<int>(42);
    // ptr 离开作用域时自动释放内存
}  // 无需手动 delete

// std::shared_ptr 共享资源所有权（引用计数）
{
    std::shared_ptr<int> a = std::make_shared<int>(10);
    std::shared_ptr<int> b = a;  // 引用计数+1
}  // 当最后一个 shared_ptr 销毁时释放内存

2. 文件操作

封装文件句柄，确保文件自动关闭。

class FileHandler {
public:
    explicit FileHandler(const char* path) 
        : file(fopen(path, "r")) {
        if (!file) throw std::runtime_error("Failed to open file");
    }
    
    ~FileHandler() {
        if (file) fclose(file);  // 自动关闭文件
    }
    
    // 禁用拷贝构造和赋值，避免重复释放
    FileHandler(const FileHandler&) = delete;
    FileHandler& operator=(const FileHandler&) = delete;
    
private:
    FILE* file;
};

// 使用示例
{
    FileHandler file("data.txt");
    // 文件在作用域结束时自动关闭
}

3. 互斥锁管理

自动加锁和解锁，避免死锁。

#include <mutex>

std::mutex mtx;

void func() {
    std::lock_guard<std::mutex> lock(mtx);  // 构造时加锁
    // 临界区代码
}  // 析构时自动解锁

RAII 的优势

1. 异常安全：即使发生异常，对象的析构函数仍会被调用，资源得以释放。

   void func() {
       std::unique_ptr<int[]> arr = std::make_unique<int[]>(1000);
       // 若中间抛出异常，arr 会自动释放内存
   }
   

2. 代码简洁：无需手动编写 try-finally 或 delete 语句。

3. 资源管理统一：将资源生命周期与对象绑定，降低遗忘释放资源的风险。

对比手动资源管理

场景	手动管理	RAII
内存分配	int* p = new int; delete p;	std::unique_ptr<int> p;
文件操作	FILE* f = fopen(); fclose(f);	FileHandler f("path");
锁操作	mutex.lock(); mutex.unlock();	std::lock_guard lock(mutex);

自定义 RAII 类的设计要点

1. 明确资源边界：清晰定义资源的获取和释放方式。
2. 禁用拷贝或实现移动语义：避免资源被多次释放（如 std::unique_ptr）。
3. 异常安全：确保构造函数和析构函数不抛出异常（或正确处理异常）。

总结

RAII 是 C++ 等语言中管理资源的核心范式，通过对象生命周期自动控制资源，显著提高代码的安全性和可维护性。智能指针、标准库容器（如 std::vector）、锁管理类（如 std::lock_guard）都是 RAII 的典型应用。掌握 RAII 是编写健壮、高效代码的关键。