C++ 中的 RAII 与智能指针的最佳实践

在 C++ 代码中，资源管理总是最容易出错的地方。无论是内存、文件句柄、网络连接还是数据库事务，缺乏一致的管理方式都可能导致泄漏、悬挂引用或竞争条件。RAII（Resource Acquisition Is Initialization）为此提供了强有力的解决方案，而 C++11 之后的智能指针（std::unique_ptr、std::shared_ptr、std::weak_ptr）进一步简化了资源管理的实现。

1. RAII 的核心思想

RAII 的基本规则是：资源的获取与其生命周期绑定。构造函数获取资源，析构函数释放资源。只要对象的生命周期结束，资源就会自动被回收。这样做的好处是：

异常安全：即使异常被抛出，栈展开时也会自动调用析构函数，释放资源。
可读性：资源的生命周期与对象绑定，一目了然。
简化编码：无需手动 delete、close 或 free。

示例

class FileHandle {
public:
    explicit FileHandle(const char* path)
        : file_(std::fopen(path, "r")) {
        if (!file_) throw std::runtime_error("Open failed");
    }
    ~FileHandle() {
        if (file_) std::fclose(file_);
    }
    // 禁止拷贝
    FileHandle(const FileHandle&) = delete;
    FileHandle& operator=(const FileHandle&) = delete;
    // 允许移动
    FileHandle(FileHandle&& other) noexcept : file_(other.file_) {
        other.file_ = nullptr;
    }
    FileHandle& operator=(FileHandle&& other) noexcept {
        if (this != &other) {
            if (file_) std::fclose(file_);
            file_ = other.file_;
            other.file_ = nullptr;
        }
        return *this;
    }

    std::FILE* get() const { return file_; }

private:
    std::FILE* file_;
};

使用时：

try {
    FileHandle fh("data.txt");
    // 读取文件
} catch (const std::exception& e) {
    // 资源已自动释放
}

2. 智能指针概述

C++11 提供了三种智能指针，每种都有不同的语义与适用场景。

指针	语义	适用场景	典型问题
`std::unique_ptr`	独占所有权	单一对象所有权、所有权转移	需要手动转移所有权
`std::shared_ptr`	共享所有权	多个对象共享同一资源	循环引用导致内存泄漏
`std::weak_ptr`	弱引用	防止循环引用	必须先锁定为 `shared_ptr` 才能使用

2.1 `std::unique_ptr`

最常用的智能指针，具有“独占”语义，默认使用 delete 释放资源。其特点：

不能被复制，只能移动。
可与自定义删除器配合使用（如 std::unique_ptr<FILE, decltype(&fclose)>）。

std::unique_ptr<FILE, decltype(&fclose)> fh(
    std::fopen("data.txt", "r"), &fclose);

2.2 `std::shared_ptr`

当资源需要在多个对象之间共享时使用。内部维护引用计数。

auto data = std::make_shared<std::vector<int>>(100);
auto copy = data; // 引用计数 +1

注意避免循环引用，例如：

struct Node {
    std::shared_ptr <Node> next;
    std::weak_ptr <Node> prev; // 使用 weak_ptr 防止循环
};

2.3 `std::weak_ptr`

弱引用指针，用来观察 shared_ptr 所管理的对象而不增加引用计数。使用时需要先将其“锁”到 shared_ptr。

std::weak_ptr <int> wp = sp;
if (auto sp2 = wp.lock()) { // sp2 为 shared_ptr
    // 可以安全使用
}

3. 最佳实践

默认使用 unique_ptr
在大多数情况下，资源拥有者是唯一的。除非你需要共享，否则不要使用 shared_ptr。
使用 make_unique / make_shared
通过工厂函数分配对象可以避免两次内存分配，且更安全。
```
auto p = std::make_unique <MyClass>(args...);
```
避免裸指针与智能指针混用
只在必要时（例如 API 只接受裸指针）才转换。
```
void foo(MyClass* p); // 不推荐
foo(p.get()); // 只读使用
```

自定义删除器
当资源不是普通 new/delete 分配时，使用自定义删除器。

struct MyDeleter {
    void operator()(FILE* fp) const {
        if (fp) std::fclose(fp);
    }
};
std::unique_ptr<FILE, MyDeleter> fp(std::fopen("file", "r"));

防止循环引用
对于 shared_ptr 形成的对象图，使用 weak_ptr 断开至少一条边。
在异常安全代码中使用 RAII
将所有资源管理逻辑封装进类，确保在异常抛出时资源释放。

4. 代码示例：一个线程安全的缓存

下面给出一个使用 shared_ptr 与 weak_ptr 的线程安全缓存实现，演示了 RAII 与智能指针的结合。

#include <unordered_map>
#include <memory>
#include <mutex>
#include <string>

template<typename Key, typename Value>
class ThreadSafeCache {
public:
    std::shared_ptr <Value> get(const Key& key) {
        std::unique_lock<std::mutex> lock(mutex_);
        auto it = cache_.find(key);
        if (it != cache_.end()) {
            // weak_ptr 变成 shared_ptr
            if (auto sp = it->second.lock()) {
                return sp;
            }
            // 已失效，删除
            cache_.erase(it);
        }
        // 创建新值
        auto newVal = std::make_shared <Value>(loadFromSource(key));
        cache_[key] = newVal; // 存入 weak_ptr
        return newVal;
    }

private:
    Value loadFromSource(const Key& key) {
        // 假设从磁盘读取
        return Value(); // 省略实现
    }

    std::unordered_map<Key, std::weak_ptr<Value>> cache_;
    std::mutex mutex_;
};

提示：如果缓存需要支持按需销毁，结合 std::condition_variable 或 LRU 策略可进一步优化。

5. 小结

RAII 是 C++ 资源安全的基石，保证资源在对象生命周期结束时自动释放。
智能指针 与 RAII 配合使用，消除了手动 delete 的痛点。
unique_ptr：首选，性能好，语义清晰。
shared_ptr + weak_ptr：在需要共享所有权且避免循环引用时使用。
自定义删除器：使智能指针兼容非标准资源。

遵循这些最佳实践，你的 C++ 代码将更加安全、可维护，并能显著降低资源泄漏的风险。

1. RAII 的核心思想

示例

2. 智能指针概述

2.1 std::unique_ptr

2.2 std::shared_ptr

2.3 std::weak_ptr