4. RAII 与智能指针：C++ RAII 设计模式、unique_ptr、shared_ptr、weak_ptr 实战

好，咱们今天聊一个硬核话题——RAII 和智能指针。

说实话，我见过太多 C++ 项目，代码写得挺漂亮，但一到内存管理就翻车。要么是 new 了忘 delete，要么是到处裸指针飞来飞去，最后查内存泄漏查到怀疑人生。我自己早期也踩过不少坑，后来才真正理解 RAII 的价值。

4.1 RAII 设计模式：资源管理的基石

RAII，全称 Resource Acquisition Is Initialization。名字挺绕口，但核心思想很简单：资源在构造函数中获取，在析构函数中释放。

说白了，就是让对象的生命周期来管理资源。你想想看，C++ 的局部对象在离开作用域时会自动调用析构函数，这个机制天然适合做资源清理。

我在项目中遇到过这样一个场景：一个网络服务模块，每次请求都要打开文件、分配缓冲区、加锁。最初代码里到处是 goto 和 try-catch 来保证资源释放，维护起来简直噩梦。后来全部改成 RAII 封装，代码量减少 40%，而且再也没出过资源泄漏。

来看个典型例子：

// 不推荐：手动管理
void bad_example() {
    FILE* file = fopen("test.txt", "r");
    if (!file) return;
    char* buffer = new char[1024];
    // ... 业务逻辑 ...
    if (some_error) {
        delete[] buffer;
        fclose(file);
        return;
    }
    delete[] buffer;
    fclose(file);
}

// 推荐：RAII 封装
class FileGuard {
    FILE* file_;
public:
    explicit FileGuard(const char* name) {
        file_ = fopen(name, "r");
        if (!file_) throw std::runtime_error("open failed");
    }
    ~FileGuard() { if (file_) fclose(file_); }
    FILE* get() const { return file_; }
};

void good_example() {
    FileGuard file("test.txt");
    auto buffer = std::make_unique<char[]>(1024);
    // ... 业务逻辑，异常安全 ...
    // 离开作用域自动释放
}

4.2 unique_ptr：独占所有权的利器

std::unique_ptr 是我用得最多的智能指针。它代表独占所有权——同一时刻只有一个指针能拥有这块内存。

为什么我喜欢它？因为语义清晰。你看到 unique_ptr，就知道这个资源是独占的，不需要考虑共享问题。而且它零开销，跟裸指针一样快。

// 基本用法
auto ptr = std::make_unique<int>(42);
// 不能拷贝，只能移动
auto ptr2 = std::move(ptr);  // 所有权转移
// ptr 现在为空

// 在容器中使用
std::vector<std::unique_ptr<Widget>> widgets;
widgets.push_back(std::make_unique<Widget>());
// 容器销毁时自动释放所有 Widget

我曾经接手过一个老项目，里面大量使用裸指针 new/delete，而且指针到处传递，根本搞不清谁该负责释放。后来我花了两个周末，把所有明确是独占所有权的指针改成 unique_ptr，内存泄漏直接归零。

4.3 shared_ptr：共享所有权的双刃剑

std::shared_ptr 通过引用计数实现共享所有权。每次拷贝会增加引用计数，析构时减少，计数归零时释放资源。

嗯，这里要注意：shared_ptr 虽然方便，但用不好会出大问题。

特性	unique_ptr	shared_ptr
所有权	独占	共享
开销	零开销（与裸指针相同）	额外控制块（引用计数）
拷贝	禁止（只能移动）	允许（引用计数+1）
线程安全	是（移动操作）	引用计数线程安全，对象本身不保证

// shared_ptr 基本用法
auto sp1 = std::make_shared<int>(100);
auto sp2 = sp1;  // 引用计数变为 2
// 两个指针共享同一块内存

// 自定义删除器
auto sp3 = std::shared_ptr<FILE>(
    fopen("test.txt", "r"),
    [](FILE* f) { if (f) fclose(f); }
);

4.4 weak_ptr：破解循环引用的钥匙

循环引用是 shared_ptr 最常见的坑。比如 A 持有 B 的 shared_ptr，B 也持有 A 的 shared_ptr，两个对象的引用计数永远不为零，内存泄漏。

std::weak_ptr 就是来解决这个问题的。它像一个"弱引用"，不增加引用计数。你需要使用时，通过 lock() 方法获取一个 shared_ptr。

class Node {
    std::shared_ptr<Node> next_;
    std::weak_ptr<Node> prev_;  // 用 weak_ptr 避免循环引用
public:
    void set_next(std::shared_ptr<Node> n) { next_ = n; }
    void set_prev(std::shared_ptr<Node> p) { prev_ = p; }
    
    std::shared_ptr<Node> get_prev() {
        return prev_.lock();  // 返回 shared_ptr，如果对象已释放则返回空
    }
};

我曾经在实现一个观察者模式时踩过这个坑。Subject 持有 Observer 的 shared_ptr，Observer 也持有 Subject 的 shared_ptr，结果两个对象都释放不了。后来改成 weak_ptr，问题迎刃而解。

4.5 实战：智能指针在大型工程中的落地策略

光讲理论不够，咱们看看实际项目中怎么用。

我参与过一个分布式存储系统，代码量百万级。我们的内存管理策略是这样的：

1. 接口层：所有公开 API 返回 unique_ptr，明确所有权转移
2. 内部缓存：使用 shared_ptr + weak_ptr 实现 LRU 缓存
3. 异步回调：用 shared_ptr 延长对象生命周期，确保回调执行时对象还在
4. 对象池：自定义 RAII 封装，避免频繁分配释放

// 缓存系统示例
class Cache {
    std::unordered_map<std::string, std::weak_ptr<Data>> cache_;
    std::mutex mtx_;
public:
    std::shared_ptr<Data> get(const std::string& key) {
        std::lock_guard<std::mutex> lock(mtx_);
        auto it = cache_.find(key);
        if (it == cache_.end()) return nullptr;
        auto sp = it->second.lock();
        if (!sp) cache_.erase(it);  // 清理过期条目
        return sp;
    }
    
    void put(const std::string& key, std::shared_ptr<Data> data) {
        std::lock_guard<std::mutex> lock(mtx_);
        cache_[key] = data;
    }
};

4.6 知识体系总览

下面这张图总结了 RAII 和智能指针的核心逻辑，我建议你保存下来，写代码时对照着看：

好了，RAII 和智能指针的内容就讲到这里。这些工具用好了，你的 C++ 代码会干净很多，内存泄漏也会大幅减少。记住一点：明确所有权，用 RAII 封装资源，这是大型工程中内存管理的基石。