C++ 智能指针：彻底解决内存泄漏问题

std::unique_ptr（独占所有权）

C++11 引入，底层参考了 Boost。它的特点是不能拷贝、不能赋值，只能移动。一个资源同一时间只能被一个 unique_ptr 管理，非常适合不需要共享资源的场景。

模拟实现要点：

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

private:
    T* _ptr;
};

std::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;
        }
    }
    
    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;
    }

private:
    T* _ptr;
    int* _pcount;
    function<void(T*)> _del = [](T* ptr){ delete ptr; };
};

shared_ptr 的一个弊端：循环引用

当两个对象互相持有对方的 shared_ptr 时，引用计数永远无法归零，导致内存泄漏。这时候需要搭配 weak_ptr 使用。

std::weak_ptr（弱引用）

weak_ptr 不参与资源管理，只观察。它不会增加引用计数，专门用来打破循环引用。它可以转换成 shared_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;
    }

private:
    T* _ptr;
};

删除定制器

有时候资源不是用 new 分配的，可能是 malloc 或 new[]，直接用默认 delete 会出错。这时需要自定义删除器（Deleter）。

例如处理数组：

shared_ptr<int[]> sp(new int[10], [](int* p){ delete[] p; });

这样在 shared_ptr 析构时，会调用这个 lambda 而不是默认的 delete。

总结

智能指针是现代 C++ 内存管理的基石。unique_ptr 适合独占场景，shared_ptr 配合 weak_ptr 解决共享与循环引用，而自定义删除器则提供了灵活性。掌握它们，能让你的代码更安全、更简洁。