Effective C++ 条款15：在资源管理类中提供对原始资源的访问

APIs 往往要求访问原始资源（raw resources），所以每一个 RAII class 应该提供一个"取得其所管理之资源"的办法。对原始资源的访问可能经过显式转换或隐式转换，一般而言显式转换比较安全，但隐式转换对客户比较方便。

一、为什么需要访问原始资源？

RAII 类封装了资源，提供了自动管理的能力。但现实世界中，很多现有的 API 并不认识我们的 RAII 类，它们只接受原始资源：

#include <memory>

// C 风格的文件 API
FILE* fopen(const char* filename, const char* mode);
int fclose(FILE* stream);
size_t fread(void* ptr, size_t size, size_t nmemb, FILE* stream);

// 我们的 RAII 类
class FileGuard {
public:
    explicit FileGuard(const char* filename)
        : file_(fopen(filename, "r")) {
        if (!file_) throw std::runtime_error("Failed to open file");
    }
    
    ~FileGuard() { if (file_) fclose(file_); }
    
    // 问题来了：如何让 fread 使用我们的 FileGuard？

private:
    FILE* file_;
};

// 需要访问原始 FILE* 的场景
void readData(FileGuard& guard) {
    // fread 需要 FILE*，但 guard 是 FileGuard 类型
    // char buffer[1024];
    // fread(buffer, 1, 1024, guard);  // 编译错误！
}

类似的情况无处不在：

场景 RAII 类 需要的原始资源
文件操作 FileGuard FILE*
内存管理 std::unique_ptr<T> T*
互斥锁 std::lock_guard std::mutex*（内部使用）
网络编程 SocketGuard int (socket fd)
GUI 开发 DeviceContext HDC (Windows)
数据库 ConnectionGuard MYSQL*

二、两种访问方式

方式一：显式转换（Explicit Conversion）

通过成员函数显式提供原始资源的访问：

class FileGuard {
public:
    explicit FileGuard(const char* filename)
        : file_(fopen(filename, "r")) {
        if (!file_) throw std::runtime_error("Failed to open file");
    }
    
    ~FileGuard() { if (file_) fclose(file_); }
    
    // 显式转换：通过 get() 方法获取原始资源
    FILE* get() const { return file_; }
    
    // 禁止拷贝，允许移动
    FileGuard(const FileGuard&) = delete;
    FileGuard& operator=(const FileGuard&) = delete;
    FileGuard(FileGuard&& other) noexcept : file_(other.file_) {
        other.file_ = nullptr;
    }

private:
    FILE* file_;
};

// 使用显式转换
void readData(FileGuard& guard) {
    char buffer[1024];
    size_t n = fread(buffer, 1, 1024, guard.get());  // 显式调用 get()
    // 安全、清晰，一眼就能看出在访问原始资源
}

显式转换的优点：

  • 安全性高：不会意外暴露原始资源
  • 代码可读性好：.get() 明确表达了访问原始资源的意图
  • 便于调试：可以在 get() 中添加日志或断言

方式二：隐式转换（Implicit Conversion）

通过类型转换操作符或转换构造函数，让 RAII 类自动转换为原始资源类型：

class FileGuard {
public:
    explicit FileGuard(const char* filename)
        : file_(fopen(filename, "r")) {
        if (!file_) throw std::runtime_error("Failed to open file");
    }
    
    ~FileGuard() { if (file_) fclose(file_); }
    
    // 隐式转换操作符
    operator FILE*() const { return file_; }
    
    // 同样提供显式转换
    FILE* get() const { return file_; }

private:
    FILE* file_;
};

// 使用隐式转换
void readData(FileGuard& guard) {
    char buffer[1024];
    size_t n = fread(buffer, 1, 1024, guard);  // 隐式转换为 FILE*
    // 方便，但可能隐藏问题
}

隐式转换的优点：

  • 使用方便：无需显式调用 .get()
  • 与旧 API 兼容性好：可以无缝替换原始资源参数

隐式转换的缺点：

void processFile(FILE* file);  // 某个 API

FileGuard guard("data.txt");
processFile(guard);  // 隐式转换，看起来 guard 被传进去了

// 但这里有一个陷阱：
FILE* raw = guard;   // 隐式转换，现在 raw 和 guard 管理同一资源
// 如果 guard 先析构，raw 就变成悬空指针！

三、标准库的做法

std::unique_ptr：显式转换

#include <memory>

std::unique_ptr<int> ptr = std::make_unique<int>(42);

// 显式获取原始指针
int* raw = ptr.get();  // 明确、安全

// 不支持隐式转换
// int* raw2 = ptr;  // 编译错误！

// 显式释放并获取所有权
int* released = ptr.release();  // ptr 不再管理该资源
// 现在需要手动 delete released

std::shared_ptr：显式转换

std::shared_ptr<int> shared = std::make_shared<int>(42);

// 显式获取原始指针
int* raw = shared.get();

// 获取引用计数
long count = shared.use_count();

智能指针的自定义删除器

// 使用自定义删除器管理非内存资源
auto fileDeleter = [](FILE* f) { 
    if (f) fclose(f); 
};

std::unique_ptr<FILE, decltype(fileDeleter)> 
    file(fopen("data.txt", "r"), fileDeleter);

// 访问原始 FILE*
FILE* raw = file.get();
fread(buffer, 1, 1024, file.get());

四、显式 vs 隐式：如何选择？

考量因素 显式转换（get） 隐式转换（operator T*）
安全性 高，不会意外暴露 低，可能意外转换
便利性 需要写 .get() 直接传递对象
代码清晰度 高，意图明确 低，转换隐藏
调试难度 低，可在 get() 加断点 高，转换不易追踪
与旧 API 兼容性 需要修改调用代码 无缝兼容
推荐程度 强烈推荐 谨慎使用

一般原则

优先使用显式转换，只在确实需要与大量旧 API 无缝集成时考虑隐式转换。

五、实际应用场景

场景1：Windows GDI 资源管理

#include <windows.h>

// RAII 封装 HDC
class DeviceContext {
public:
    explicit DeviceContext(HWND hwnd) 
        : hwnd_(hwnd), hdc_(GetDC(hwnd)) {}
    
    ~DeviceContext() { 
        if (hdc_) ReleaseDC(hwnd_, hdc_); 
    }
    
    // 显式转换（推荐）
    HDC get() const { return hdc_; }
    
    // 隐式转换（可选，用于大量 GDI 函数调用）
    operator HDC() const { return hdc_; }

private:
    HWND hwnd_;
    HDC hdc_;
};

// 使用
void drawRectangle(HWND hwnd) {
    DeviceContext dc(hwnd);
    
    // 显式转换
    Rectangle(dc.get(), 10, 10, 100, 100);
    
    // 或使用隐式转换
    Rectangle(dc, 10, 10, 100, 100);  // dc 隐式转换为 HDC
}

场景2：数据库连接封装

#include <mysql/mysql.h>

class MySQLConnection {
public:
    explicit MySQLConnection(const char* host, const char* user, 
                              const char* password, const char* db) {
        conn_ = mysql_init(nullptr);
        if (!mysql_real_connect(conn_, host, user, password, db, 0, nullptr, 0)) {
            throw std::runtime_error(mysql_error(conn_));
        }
    }
    
    ~MySQLConnection() {
        if (conn_) mysql_close(conn_);
    }
    
    // 显式获取原始连接（推荐）
    MYSQL* get() const { return conn_; }
    
    // 禁止拷贝，允许移动
    MySQLConnection(const MySQLConnection&) = delete;
    MySQLConnection& operator=(const MySQLConnection&) = delete;
    MySQLConnection(MySQLConnection&& other) noexcept 
        : conn_(other.conn_) {
        other.conn_ = nullptr;
    }

private:
    MYSQL* conn_;
};

// 使用
void executeQuery(MySQLConnection& conn, const char* sql) {
    // 必须使用显式转换
    if (mysql_query(conn.get(), sql) != 0) {
        throw std::runtime_error(mysql_error(conn.get()));
    }
    
    MYSQL_RES* result = mysql_store_result(conn.get());
    // ... 处理结果 ...
    mysql_free_result(result);
}

场景3：OpenGL 资源管理

// OpenGL 纹理 RAII 封装
class Texture {
public:
    Texture() { glGenTextures(1, &id_); }
    ~Texture() { if (id_) glDeleteTextures(1, &id_); }
    
    // 显式获取纹理 ID
    GLuint get() const { return id_; }
    
    // 绑定纹理（常用操作，可直接封装）
    void bind() const { glBindTexture(GL_TEXTURE_2D, id_); }
    
    // 禁止拷贝
    Texture(const Texture&) = delete;
    Texture& operator=(const Texture&) = delete;
    
    // 允许移动
    Texture(Texture&& other) noexcept : id_(other.id_) {
        other.id_ = 0;
    }

private:
    GLuint id_;
};

// 使用
void setupTexture(Texture& tex) {
    tex.bind();  // 优先使用封装好的方法
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 
                 0, GL_RGBA, GL_UNSIGNED_BYTE, data);
    
    // 需要原始 ID 时显式获取
    glActiveTexture(GL_TEXTURE0);
    glBindTexture(GL_TEXTURE_2D, tex.get());
}

场景4：C 语言 API 的封装

extern "C" {
    // 某个 C 库 API
    typedef struct curl_handle curl_t;
    curl_t* curl_init();
    void curl_cleanup(curl_t* curl);
    int curl_perform(curl_t* curl);
    int curl_setopt(curl_t* curl, int option, ...);
}

class CurlHandle {
public:
    CurlHandle() : curl_(curl_init()) {
        if (!curl_) throw std::runtime_error("Failed to init curl");
    }
    
    ~CurlHandle() { 
        if (curl_) curl_cleanup(curl_); 
    }
    
    // 显式转换
    curl_t* get() const { return curl_; }
    
    // 封装常用操作
    void setOption(int option, long value) {
        curl_setopt(curl_, option, value);
    }
    
    void perform() {
        if (curl_perform(curl_) != 0) {
            throw std::runtime_error("curl perform failed");
        }
    }

private:
    curl_t* curl_;
};

// 使用
void fetchUrl(const std::string& url) {
    CurlHandle curl;
    curl.setOption(1, 1L);  // CURLOPT_VERBOSE
    // ... 更多设置 ...
    curl.perform();
}

六、隐式转换的安全使用

如果确实需要隐式转换，可以通过一些技巧降低风险：

使用 explicit 转换操作符（C++11）

class SafeImplicit {
public:
    explicit SafeImplicit(int* p) : ptr_(p) {}
    
    // C++11 显式转换操作符
    explicit operator int*() const { return ptr_; }
    
    // 隐式 bool 转换（常用于条件判断）
    explicit operator bool() const { return ptr_ != nullptr; }

private:
    int* ptr_;
};

SafeImplicit si(new int(42));

// 需要显式转换
int* p = static_cast<int*>(si);  // OK
// int* p2 = si;  // 编译错误！explicit 阻止隐式转换

// bool 转换在条件中可用
if (si) {  // OK，显式转换操作符在条件中可用
    // ...
}

返回 const 原始资源

class ConstAccess {
public:
    explicit ConstAccess(int* p) : ptr_(p) {}
    
    // 返回 const 指针，防止通过原始资源修改
    const int* get() const { return ptr_; }
    int* get() { return ptr_; }  // 非 const 版本
    
    // 隐式转换只提供 const 访问
    operator const int*() const { return ptr_; }

private:
    int* ptr_;
};

七、常见陷阱

陷阱1：返回的原始资源生命周期问题

FILE* getFile() {
    FileGuard guard("data.txt");
    return guard.get();  // 危险！guard 析构后 FILE* 被关闭
}

// 正确做法：返回 RAII 对象
FileGuard openFile() {
    return FileGuard("data.txt");  // 移动语义
}

陷阱2：通过原始资源释放资源

std::unique_ptr<int> ptr(new int(42));
int* raw = ptr.get();
delete raw;  // 危险！ptr 析构时会再次 delete

// 正确做法：不要手动释放 get() 返回的指针
// 如果需要转移所有权，使用 release()
int* released = ptr.release();  // ptr 不再管理
// 现在可以手动 delete released，或交给另一个智能指针
std::unique_ptr<int> ptr2(released);

陷阱3：隐式转换导致的意外行为

class ResourceHandle {
public:
    ResourceHandle(int* p) : ptr_(p) {}
    operator int*() const { return ptr_; }

private:
    int* ptr_;
};

void process(int* p);

ResourceHandle handle(new int(42));
process(handle);  // 隐式转换，看起来没问题

// 但下面的代码就危险了：
bool isNull = !handle;  // 隐式转换为 int*，再转为 bool
// 或者更隐蔽的：
int value = handle + 1;  // 指针算术！可能不是预期行为

八、最佳实践总结

  1. 始终提供显式转换方法（如 get()）
T* get() const { return ptr_; }

  1. 谨慎提供隐式转换，仅在以下情况考虑：

    • 需要与大量旧 API 无缝集成
    • 类的语义就是资源的包装器
    • 使用 explicit 转换操作符（C++11）

  2. 优先封装操作而非暴露资源

// 好：封装常用操作
class FileGuard {
public:
    size_t read(void* buffer, size_t size);
    size_t write(const void* buffer, size_t size);
    void seek(long offset);
    // 只在必要时暴露原始资源
    FILE* get() const;
};
  1. 文档化资源所有权
/**
 * @return 返回管理的原始 FILE* 指针。
 * @note 返回的指针仍由本对象管理，调用者不应释放它。
 * @note 当本对象析构后，返回的指针将失效。
 */
FILE* get() const;

/**
 * @return 释放资源所有权并返回原始指针。
 * @note 调用者负责释放返回的指针。
 */
FILE* release();

九、总结

请记住：

  • APIs 往往要求访问原始资源，所以每个 RAII class 应该提供取得其所管理之资源的办法
  • 对原始资源的访问可以通过显式转换（如 get()）或隐式转换（如类型转换操作符）
  • 显式转换比较安全，可以明确表达访问原始资源的意图
  • 隐式转换对客户比较方便，但可能引入隐蔽的错误
  • 一般而言，优先使用显式转换，谨慎使用隐式转换

RAII 类封装了资源管理，但无法完全隔离原始资源。合理设计原始资源的访问接口，既能享受 RAII 带来的安全和便利，又能与现有的 API 生态和平共处。显式转换是更安全的默认选择，隐式转换则是需要权衡利弊后的谨慎决策。

参考阅读：

  • 《Effective C++》第3版，Scott Meyers，条款15
  • 《Effective Modern C++》，Scott Meyers
  • C++ Core Guidelines: F.7, F.8, R.30
  • cppreference.com: 显式转换操作符（C++11）
# c++ # stm32 # 单片机 # linux # 开发语言
Logo
AtomGit开源社区

AtomGit 是由开放原子开源基金会联合 CSDN 等生态伙伴共同推出的新一代开源与人工智能协作平台。平台坚持“开放、中立、公益”的理念，把代码托管、模型共享、数据集托管、智能体开发体验和算力服务整合在一起，为开发者提供从开发、训练到部署的一站式体验。

更多推荐

cover

调用 Claude API 不设超时，为什么你的服务总是挂？

avatar AtomGit开源社区

Web3新时代来临！HappyPlanet 快乐星球：让科技为快乐与价值赋能！

当区块链技术打破价值壁垒，AI 智能赋能数字生活，元宇宙重塑人机交互形态，我们的数字世界，正告别碎片化、单一化的传统模式，向着可信、开放、共赢、有趣的全新生态迭代。

avatar AtomGit开源社区
cover

标准体系构建：企业大模型 API 采购中 DMXAPI 的运营与服务剖析

avatar AtomGit开源社区