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

std::unique_ptr (独占所有权)

C++11 引入的标准配置。unique_ptr 的核心规则是：独占资源，不可拷贝。它确保了同一时刻只有一个智能指针拥有该资源的所有权，非常适合一对一的场景。

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(const unique_ptr<T>&) = delete;
    unique_ptr& operator=(const unique_ptr<T>&) = delete;

private:
    T* _ptr;
};

注意：实际使用中，我们通常配合移动语义（Move Semantics）来转移 unique_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() {
        // 引用计数减一，若为 0 则释放资源
        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& 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 时，引用计数永远无法归零，导致内存泄漏。解决这个问题的搭档就是 weak_ptr。

std::weak_ptr (弱引用)

weak_ptr 不管理资源，不参与引用计数。它的作用仅仅是观察 shared_ptr 管理的对象是否存在。它可以打破循环引用链。

weak_ptr 模拟实现

template<class T>
class weak_ptr {
public:
    weak_ptr() : _ptr(nullptr) {}
    
    // 从 shared_ptr 转换
    weak_ptr(const shared_ptr<T>& sp) : _ptr(sp.get()) {}
    
    weak_ptr& operator=(const shared_ptr<T>& sp) {
        _ptr = sp.get();
        return *this;
    }
    
    // 注意：解引用前需检查是否有效
    T& operator*() { return *_ptr; }
    T* operator->() { return _ptr; }

private:
    T* _ptr;
};

删除定制器 (Custom Deleter)

默认的智能指针使用 delete 释放内存。但如果资源是通过 new[] 或 malloc 分配的，就需要自定义删除器。

例如，处理数组时应使用 delete[]，处理文件句柄应调用 fclose。shared_ptr 和 unique_ptr 都支持在构造时传入自定义的删除函数对象。

总结

• auto_ptr：已过时，所有权转移机制危险，避免使用。
• unique_ptr：独占资源，性能高，无额外开销，首选方案。
• shared_ptr：共享资源，有引用计数开销，注意循环引用。
• weak_ptr：辅助 shared_ptr 解决循环引用，不增加引用计数。

掌握这些工具，能让你的 C++ 程序在内存安全上迈出一大步。