智能指针详解：RAII 原理与 C++ 标准库实践

std::unique_ptr

C++11 引入的智能指针，代表独占所有权。它禁止拷贝和赋值，确保同一时间只有一个指针拥有资源。底层实现通常通过删除拷贝构造函数和赋值运算符来实现。

unique_ptr 模拟实现

template <class T>
class unique_ptr {
public:
    unique_ptr(T* ptr) : _ptr(ptr) {}
    ~unique_ptr() { delete _ptr; }
    
    T& operator*() { return *_ptr; }
    T* operator->() { return _ptr; }
    
    // 禁止拷贝和赋值
    unique_ptr(unique_ptr<T>&) = delete;
    unique_ptr<T>& operator=(unique_ptr<T>&) = delete;
    
private:
    T* _ptr;
};

std::shared_ptr

这是最常用的智能指针，支持共享所有权。多个 shared_ptr 可以指向同一资源，通过引用计数来管理生命周期。当计数归零时，资源被释放。

shared_ptr 模拟实现

template <class T>
class shared_ptr {
public:
    shared_ptr(T* ptr = nullptr) : _ptr(ptr), _pcount(new int(1)) {}
    
    template <class D>
    shared_ptr(T* ptr, D del) : _ptr(ptr), _pcount(new int(1)), _del(del) {}
    
    ~shared_ptr() {
        if (--(*_pcount) == 0) {
            _del(_ptr);
            delete _pcount;
        }
    }
    
    T& operator*() { return *_ptr; }
    T* operator->() { return _ptr; }
    
    shared_ptr(const shared_ptr<T>& sp) : _ptr(sp._ptr), _pcount(sp._pcount) {
        ++(*_pcount);
    }
    
    shared_ptr<T>& operator=(const shared_ptr<T>& sp) {
        if (_ptr == sp._ptr) return *this;
        if (--(*_pcount) == 0) {
            _del(_ptr);
            delete _pcount;
        }
        _ptr = sp._ptr;
        _pcount = sp._pcount;
        ++(*_pcount);
        return *this;
    }
    
    T* get() const { return _ptr; }
    
private:
    T* _ptr;
    int* _pcount;
    std::function<void(T*)> _del = [](T* ptr){ delete ptr; };
};

shared_ptr 的一个弊端

当两个 shared_ptr 互相持有对方时，引用计数永远无法归零，导致内存泄漏。这就是著名的循环引用问题。

std::weak_ptr

为了解决 shared_ptr 的循环引用问题，C++ 提供了 weak_ptr。它不管理资源，不参与引用计数，仅观察资源是否存活。它可以将 shared_ptr 转换为 weak_ptr，反之亦然。

weak_ptr 模拟实现

template <class T>
class weak_ptr {
public:
    weak_ptr() : _ptr(nullptr) {}
    
    weak_ptr(const shared_ptr<T>& sp) : _ptr(sp.get()) {}
    
    weak_ptr<T>& operator=(const shared_ptr<T>& sp) {
        _ptr = sp.get();
        return *this;
    }
    
    // 注意：实际使用中需先 lock() 转为 shared_ptr 才能访问
    T& operator*() { return *_ptr; }
    T* operator->() { return _ptr; }
    
private:
    T* _ptr;
};

删除定制器

在某些场景下，资源可能不是通过 new 分配的（例如 malloc 或数组 new[]），此时默认的 delete 无法正确释放。智能指针允许传入自定义的删除器（Deleter）来处理特定资源的释放逻辑。

在上面的 shared_ptr 实现中，我们已经预留了 _del 成员变量来支持这一功能。在实际开发中，应优先使用标准库提供的工具类，如 std::make_unique 或 std::make_shared，它们能更安全地处理内存分配与初始化。