17、智能指针与RAII：资源管理的现代C++之道

说实话，智能指针这个话题，我每次讲都觉得特别有感触。早些年我刚入行时，项目里全是裸指针，new/delete满天飞。那时候最怕的就是内存泄漏，每次上线前都要用Valgrind跑一遍，看到"definitely lost"的红色警告就头皮发麻。后来C++11引入了智能指针，我才算真正从手动内存管理中解放出来。

今天咱们就来聊聊智能指针和RAII。这玩意儿说白了就是：让对象的生命周期和资源绑定在一起。你想想看，如果资源能自动释放，那该多省心？

RAII：资源获取即初始化

RAII（Resource Acquisition Is Initialization）是C++里一个核心思想。名字听着高大上，其实道理很简单：在构造函数里获取资源，在析构函数里释放资源。

我习惯把RAII理解为"资源跟着对象走"。对象活着，资源就在；对象死了，资源自动释放。这样就不会出现忘记释放资源的情况。

智能指针就是RAII思想最典型的应用。它们管理的是堆内存，但原理同样适用于文件句柄、网络连接、数据库会话等任何需要手动释放的资源。

unique_ptr：独占所有权

unique_ptr是我用得最多的智能指针。它的特点就四个字：独占所有权。一个unique_ptr指向的资源，同一时刻只能有一个所有者。

#include <memory>
#include <iostream>

class Resource {
public:
    Resource() { std::cout << "Resource acquired\n"; }
    ~Resource() { std::cout << "Resource released\n"; }
    void doWork() { std::cout << "Working...\n"; }
};

void demoUniquePtr() {
    // 创建独占指针
    std::unique_ptr<Resource> ptr1 = std::make_unique<Resource>();
    
    // 不能拷贝，只能移动
    // std::unique_ptr<Resource> ptr2 = ptr1;  // 编译错误！
    std::unique_ptr<Resource> ptr2 = std::move(ptr1);  // 转移所有权
    
    if (ptr1 == nullptr) {
        std::cout << "ptr1 is now empty\n";
    }
    
    ptr2->doWork();
    // 离开作用域时，ptr2自动释放资源
}

我在项目中遇到过一个问题：有个同事用unique_ptr作为函数参数，传的是拷贝而不是引用。结果编译报错，他一脸懵。其实unique_ptr不能拷贝，只能移动。如果你想让函数临时访问资源，传裸指针或引用就行：

void useResource(Resource* res) {
    if (res) res->doWork();
}

// 调用时
auto ptr = std::make_unique<Resource>();
useResource(ptr.get());  // 通过get()获取裸指针

shared_ptr：引用计数

shared_ptr允许多个指针共享同一个资源。它内部维护一个引用计数，每增加一个共享者，计数加1；每销毁一个，计数减1。当计数归零时，资源自动释放。

void demoSharedPtr() {
    std::shared_ptr<Resource> sp1 = std::make_shared<Resource>();
    {
        std::shared_ptr<Resource> sp2 = sp1;  // 引用计数变为2
        std::cout << "Use count: " << sp1.use_count() << "\n";  // 输出2
    }  // sp2销毁，引用计数变为1
    std::cout << "Use count: " << sp1.use_count() << "\n";  // 输出1
}  // sp1销毁，引用计数归零，资源释放

嗯，这里要注意：shared_ptr的引用计数是线程安全的，但资源本身不是。多线程环境下，你仍然需要自己加锁保护资源。

weak_ptr：解决循环引用

weak_ptr是个"旁观者"。它指向shared_ptr管理的资源，但不增加引用计数。说白了，它就是个弱引用，不会影响资源的生命周期。

为什么要用它？因为shared_ptr有个大坑——循环引用。两个对象互相持有对方的shared_ptr，引用计数永远不为零，资源就泄漏了。

class B;  // 前置声明

class A {
public:
    std::shared_ptr<B> b_ptr;
    ~A() { std::cout << "A destroyed\n"; }
};

class B {
public:
    std::weak_ptr<A> a_ptr;  // 用weak_ptr打破循环
    ~B() { std::cout << "B destroyed\n"; }
};

void demoWeakPtr() {
    auto a = std::make_shared<A>();
    auto b = std::make_shared<B>();
    a->b_ptr = b;
    b->a_ptr = a;  // weak_ptr赋值，不增加引用计数
    // 离开作用域时，a和b都能正常释放
}

我曾经在一个缓存系统里遇到过循环引用的问题。两个缓存节点互相引用，结果内存只增不减。排查了半天才发现是shared_ptr循环了。换成weak_ptr后，问题立刻解决。

void useWeakPtr(std::weak_ptr<Resource> wp) {
    if (auto sp = wp.lock()) {  // 获取shared_ptr
        sp->doWork();
    } else {
        std::cout << "Resource already released\n";
    }
}

make_shared / make_unique：安全又高效

我强烈建议你使用make_shared和make_unique来创建智能指针，而不是直接new。原因有三：

1. 异常安全：如果构造函数抛出异常，不会造成内存泄漏
2. 代码简洁：不用写new和类型名
3. 性能更好：make_shared一次分配内存，把对象和控制块放在一起

// 推荐写法
auto ptr1 = std::make_unique<Resource>();
auto ptr2 = std::make_shared<Resource>();

// 不推荐写法（除非有特殊需求）
std::unique_ptr<Resource> ptr3(new Resource());
std::shared_ptr<Resource> ptr4(new Resource());

实战：对象池管理

好了，理论说完了，咱们来点实战。对象池是个经典场景：预先创建一批对象，用的时候从池里取，用完放回去。这样可以避免频繁的构造和析构。

我用unique_ptr和自定义删除器实现了一个简单的对象池：

#include <memory>
#include <vector>
#include <queue>
#include <mutex>

template<typename T>
class ObjectPool {
public:
    using Ptr = std::unique_ptr<T, std::function<void(T*)>>;
    
    ObjectPool(size_t size) {
        for (size_t i = 0; i < size; ++i) {
            pool_.push(new T());
        }
    }
    
    Ptr acquire() {
        std::lock_guard<std::mutex> lock(mutex_);
        if (pool_.empty()) {
            return nullptr;
        }
        T* obj = pool_.front();
        pool_.pop();
        // 自定义删除器：放回池中而不是删除
        return Ptr(obj, [this](T* ptr) {
            this->release(ptr);
        });
    }
    
    size_t available() const {
        std::lock_guard<std::mutex> lock(mutex_);
        return pool_.size();
    }
    
private:
    void release(T* obj) {
        std::lock_guard<std::mutex> lock(mutex_);
        pool_.push(obj);
    }
    
    mutable std::mutex mutex_;
    std::queue<T*> pool_;
};

// 使用示例
void demoObjectPool() {
    ObjectPool<Resource> pool(5);
    
    auto obj = pool.acquire();
    if (obj) {
        obj->doWork();
        // 离开作用域时，obj自动放回池中
    }
    
    std::cout << "Available: " << pool.available() << "\n";
}

这个对象池的精妙之处在于：利用unique_ptr的析构函数自动调用自定义删除器。用户拿到的unique_ptr用完后，不是真的释放内存，而是把对象还回池里。这样既保证了资源安全，又实现了复用。

知识体系总览

下面这张图总结了智能指针的核心关系和RAII的运作机制：

说实话，智能指针刚出来时，我也觉得不就是个自动释放内存的包装器吗？用久了才发现，它背后是所有权语义的清晰表达。你的代码里用unique_ptr还是shared_ptr，直接告诉读者：这个资源是独占的还是共享的。这种语义上的清晰，比任何注释都管用。

最后分享一个我个人的习惯：优先用unique_ptr，必要时用shared_ptr，用weak_ptr打破循环。记住这个原则，你的资源管理代码会干净很多。

---

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