C++中常见符合RAII思想的设计有哪些-优快云博客

本文链接：https://blog.youkuaiyun.com/liuwenchang1234/article/details/146703545

文章目录

在 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 类的核心原则

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

四、RAII 的优势

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

五、实际应用案例

将非 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()) {
        // 操作文件...
    }
} // 自动关闭文件