C++中常见符合RAII思想的设计有哪些

在 C++ 中，符合 RAII（Resource Acquisition Is Initialization）思想的设计广泛存在，其核心是通过对象的生命周期自动管理资源。以下是常见的 RAII 实现场景和示例：

---

一、标准库中的 RAII 类

1. 智能指针

• std::unique_ptr<T>
  独占所有权，对象析构时自动释放内存。
• std::shared_ptr<T>
  共享所有权，通过引用计数自动释放内存。
• std::weak_ptr<T>
  配合 shared_ptr 使用，避免循环引用。

{
    auto ptr = std::make_unique<int>(42); // 分配内存
    // 使用 ptr...
} // 离开作用域，内存自动释放

2. 文件操作类

• std::fstream/ifstream/ofstream
  构造时打开文件，析构时自动关闭文件。

{
    std::ofstream file("data.txt"); // 打开文件
    file << "Hello RAII"; 
} // 文件自动关闭

3. 锁管理类

• std::lock_guard
  构造时加锁，析构时自动解锁。
• std::unique_lock
  更灵活的锁管理，支持延迟加锁和手动控制。
• std::scoped_lock (C++17)
  支持同时锁定多个互斥量，避免死锁。

std::mutex mtx;
{
    std::lock_guard lock(mtx); // 加锁
    // 临界区操作...
} // 自动解锁

4. 容器类

• std::vector/std::string/std::map 等
  管理动态内存，析构时自动释放内存。

{
    std::vector<int> data(1000); // 分配内存
    // 使用 data...
} // 内存自动释放

5. 线程管理

• std::jthread (C++20)
  自动在析构时 join 线程，避免线程泄漏。

{
    std::jthread thr([] { /* 任务 */ }); 
    // 线程执行中...
} // 自动 join 线程

---

二、自定义 RAII 类的常见场景

1. 数据库连接

class DatabaseConnection {
public:
    DatabaseConnection(const std::string& url) { connect(url); }
    ~DatabaseConnection() { disconnect(); }
    // 禁用拷贝，允许移动
    DatabaseConnection(const DatabaseConnection&) = delete;
    DatabaseConnection(DatabaseConnection&&) = default;
};

{
    DatabaseConnection db("mysql://localhost");
    // 执行查询...
} // 自动断开连接

2. 图形资源管理（如 OpenGL 纹理）

class GLTexture {
public:
    GLTexture() { glGenTextures(1, &id_); }
    ~GLTexture() { glDeleteTextures(1, &id_); }
private:
    GLuint id_;
};

{
    GLTexture tex; // 生成纹理
    glBindTexture(GL_TEXTURE_2D, tex.id());
    // 渲染...
} // 自动删除纹理

3. 网络套接字

class Socket {
public:
    Socket(int port) { 
        fd_ = socket(AF_INET, SOCK_STREAM, 0);
        bind(fd_, port); 
    }
    ~Socket() { close(fd_); }
private:
    int fd_;
};

{
    Socket socket(8080); // 绑定端口
    // 处理连接...
} // 自动关闭套接字

4. 事务处理

class Transaction {
public:
    Transaction() { begin_transaction(); }
    ~Transaction() { 
        if (committed_) commit();
        else rollback();
    }
    void commit() { committed_ = true; }
private:
    bool committed_ = false;
};

{
    Transaction tx;
    // 执行数据库操作...
    tx.commit(); // 若未调用 commit()，析构时自动回滚
}

5. 临时文件清理

class TempFile {
public:
    TempFile() { 
        filename_ = generate_unique_name();
        std::ofstream(filename_).close(); 
    }
    ~TempFile() { std::remove(filename_.c_str()); }
private:
    std::string filename_;
};

{
    TempFile tmp; // 创建临时文件
    // 操作文件...
} // 自动删除文件

---

三、设计 RAII 类的核心原则

1. 构造函数获取资源，析构函数释放资源
   • 确保资源在对象生命周期内有效。
2. 处理拷贝和移动语义
   • 禁用拷贝构造函数（= delete）或定义移动语义（std::move）。
3. 异常安全
   • 即使构造函数抛出异常，已分配的资源也需释放。
4. 明确资源所有权
   • 若需共享资源，使用 shared_ptr 或自定义引用计数。

---

四、RAII 的优势

1. 避免资源泄漏
   自动释放资源，无需手动管理。
2. 简化代码
   减少 try/catch 和清理代码。
3. 异常安全
   资源在栈展开时仍能被正确释放。
4. 线程安全
   通过锁的自动管理减少死锁风险。

---

五、实际应用案例

将非 RAII 代码转换为 RAII 风格

原始代码（手动管理文件）：

FILE* file = fopen("data.txt", "r");
if (file) {
    // 操作文件...
    fclose(file); // 可能忘记调用！
}

RAII 改进：

class FileRAII {
public:
    FileRAII(const char* path, const char* mode) 
        : ptr_(fopen(path, mode)) {}
    ~FileRAII() { if (ptr_) fclose(ptr_); }
    FILE* get() const { return ptr_; }
private:
    FILE* ptr_;
};

{
    FileRAII file("data.txt", "r");
    if (file.get()) {
        // 操作文件...
    }
} // 自动关闭文件

---

总结

RAII 是 C++ 资源管理的核心范式，广泛应用于：

• 标准库工具（智能指针、文件流、锁等）。
• 自定义资源管理（数据库、网络、图形等）。
• 复杂场景（事务、临时文件、状态机等）。

通过合理设计 RAII 类，可以大幅提升代码的健壮性和可维护性，减少资源泄漏和逻辑错误。