第27章：C++中的RAII与设计原则

资源管理类的SRP，RAII如何辅助DIP

说实话，RAII（Resource Acquisition Is Initialization）这个术语，我第一次听到时觉得特别拗口。但用久了你会发现，它其实是C++里最优雅的设计之一。今天我们就来聊聊RAII和几个核心设计原则的关系。

一、RAII的本质：资源与生命周期的绑定

RAII的核心思想很简单：资源获取即初始化，资源释放即析构。说白了，就是把资源的生命周期和对象的生命周期绑定在一起。

我刚开始用C++写项目时，经常遇到资源泄漏的问题。比如打开文件忘了关闭，申请了内存忘了释放。后来用了RAII，这些问题基本都解决了。

// 非RAII方式：容易忘记释放
void bad_example() {
    FILE* file = fopen("test.txt", "r");
    // ... 使用文件
    // 如果这里抛出异常，文件永远不会关闭
    fclose(file); // 可能永远不会执行到
}

// RAII方式：自动管理
class FileGuard {
    FILE* file_;
public:
    FileGuard(const char* filename) {
        file_ = fopen(filename, "r");
        if (!file_) throw std::runtime_error("open failed");
    }
    ~FileGuard() {
        if (file_) fclose(file_);
    }
    // 禁止拷贝，允许移动
    FileGuard(const FileGuard&) = delete;
    FileGuard& operator=(const FileGuard&) = delete;
};

void good_example() {
    FileGuard file("test.txt");
    // ... 使用文件
    // 离开作用域时自动关闭
}

二、RAII与单一职责原则（SRP）

单一职责原则要求一个类只负责一件事。RAII类恰恰符合这个原则——它只负责管理一种资源。

我在项目中遇到过有人把文件读写逻辑和文件管理混在一起，结果代码变得特别难维护。正确的做法是：

• 资源管理类：只负责获取和释放资源
• 业务逻辑类：使用资源完成具体功能

// 符合SRP的资源管理类
class DatabaseConnection {
    sqlite3* db_;
public:
    DatabaseConnection(const std::string& path) {
        sqlite3_open(path.c_str(), &db_);
    }
    ~DatabaseConnection() {
        if (db_) sqlite3_close(db_);
    }
    sqlite3* get() { return db_; }
    // 禁止拷贝
    DatabaseConnection(const DatabaseConnection&) = delete;
    DatabaseConnection& operator=(const DatabaseConnection&) = delete;
};

// 业务逻辑类：只关心如何使用数据库
class UserRepository {
    DatabaseConnection& conn_;
public:
    explicit UserRepository(DatabaseConnection& conn) : conn_(conn) {}
    
    void addUser(const std::string& name) {
        // 使用conn_执行SQL
        char* errMsg = nullptr;
        std::string sql = "INSERT INTO users(name) VALUES('" + name + "')";
        sqlite3_exec(conn_.get(), sql.c_str(), nullptr, nullptr, &errMsg);
        if (errMsg) {
            std::string error(errMsg);
            sqlite3_free(errMsg);
            throw std::runtime_error(error);
        }
    }
};

你看，DatabaseConnection只负责管理数据库连接的生命周期，UserRepository只负责业务逻辑。各司其职，互不干扰。

三、RAII如何辅助依赖倒置原则（DIP）

依赖倒置原则要求：高层模块不应该依赖低层模块，两者都应该依赖抽象。RAII在这里扮演了什么角色？

嗯，这里要注意：RAII本身不是抽象机制，但它为抽象提供了安全的基础设施。

// 抽象接口
class IResource {
public:
    virtual ~IResource() = default;
    virtual void doWork() = 0;
};

// RAII包装的抽象资源
class ResourceGuard {
    std::unique_ptr<IResource> resource_;
public:
    explicit ResourceGuard(std::unique_ptr<IResource> res) 
        : resource_(std::move(res)) {}
    
    void execute() {
        if (resource_) resource_->doWork();
    }
};

// 具体实现
class FileResource : public IResource {
    std::string path_;
public:
    explicit FileResource(std::string path) : path_(std::move(path)) {}
    void doWork() override {
        std::cout << "Working with file: " << path_ << std::endl;
    }
};

class NetworkResource : public IResource {
    std::string url_;
public:
    explicit NetworkResource(std::string url) : url_(std::move(url)) {}
    void doWork() override {
        std::cout << "Connecting to: " << url_ << std::endl;
    }
};

// 高层模块：只依赖抽象
void processResource(ResourceGuard& guard) {
    guard.execute(); // 不需要知道具体是什么资源
}

为什么会这样？因为RAII把资源管理的复杂性封装起来了。高层模块只需要通过抽象接口操作资源，不需要知道资源是怎么获取和释放的。

四、RAII与依赖倒置的实战案例

我曾经在一个网络库项目中，需要支持多种传输协议。如果不用RAII，代码会变成这样：

// 糟糕的设计：高层模块直接依赖具体实现
class DataProcessor {
    TcpConnection* conn_;
public:
    void process() {
        conn_->connect();  // 直接依赖具体连接
        // ... 处理数据
        conn_->disconnect(); // 容易忘记
    }
};

用RAII+抽象接口重构后：

// 抽象连接接口
class IConnection {
public:
    virtual ~IConnection() = default;
    virtual void send(const std::string& data) = 0;
    virtual std::string receive() = 0;
};

// RAII连接管理器
class ConnectionGuard {
    std::unique_ptr<IConnection> conn_;
public:
    explicit ConnectionGuard(std::unique_ptr<IConnection> conn) 
        : conn_(std::move(conn)) {
        if (!conn_) throw std::invalid_argument("null connection");
    }
    
    IConnection* operator->() { return conn_.get(); }
    IConnection& operator*() { return *conn_; }
};

// 具体实现：TCP
class TcpConnection : public IConnection {
    int socket_;
public:
    TcpConnection(const std::string& host, int port) {
        // 建立TCP连接
        socket_ = ::socket(AF_INET, SOCK_STREAM, 0);
        // ... 连接逻辑
    }
    ~TcpConnection() {
        if (socket_ >= 0) ::close(socket_);
    }
    void send(const std::string& data) override { /* TCP发送 */ }
    std::string receive() override { /* TCP接收 */ return {}; }
};

// 具体实现：UDP
class UdpConnection : public IConnection {
    int socket_;
public:
    UdpConnection(const std::string& host, int port) {
        socket_ = ::socket(AF_INET, SOCK_DGRAM, 0);
    }
    ~UdpConnection() {
        if (socket_ >= 0) ::close(socket_);
    }
    void send(const std::string& data) override { /* UDP发送 */ }
    std::string receive() override { /* UDP接收 */ return {}; }
};

// 高层模块：只依赖抽象
class DataProcessor {
public:
    void process(ConnectionGuard& conn) {
        conn->send("Hello");
        auto response = conn->receive();
        // ... 处理响应
    }
};

五、RAII与SRP、DIP的关系图

下面这张图展示了RAII如何与SRP、DIP协同工作：

六、实践中的注意事项

说了这么多，最后分享几个我在实际项目中踩过的坑：

// 推荐的RAII类模板
template<typename T, typename Deleter>
class ResourceGuard {
    T* resource_;
    Deleter deleter_;
public:
    explicit ResourceGuard(T* res, Deleter del) 
        : resource_(res), deleter_(std::move(del)) {}
    
    ~ResourceGuard() {
        if (resource_) deleter_(resource_);
    }
    
    T* get() { return resource_; }
    const T* get() const { return resource_; }
    
    // 禁止拷贝
    ResourceGuard(const ResourceGuard&) = delete;
    ResourceGuard& operator=(const ResourceGuard&) = delete;
    
    // 允许移动
    ResourceGuard(ResourceGuard&& other) noexcept 
        : resource_(other.resource_), deleter_(std::move(other.deleter_)) {
        other.resource_ = nullptr;
    }
};

总结一下：RAII是C++资源管理的基石。它天然符合SRP，让每个类只负责一件事。同时，它为DIP提供了安全的基础，让高层模块可以放心地依赖抽象接口，而不必担心资源泄漏。你想想看，如果没有RAII，我们每次调用抽象接口都要手动管理资源，那代码得多乱啊。

好了，这一章就到这里。记住：好的设计不是一蹴而就的，而是在实践中不断打磨出来的。

---

公众号:蓝海资料掘金营，微信deep3321