C++ 智能指针详解：原理、实现与内存管理最佳实践

std::unique_ptr

C++11 引入，代表独占所有权。它禁止拷贝和赋值，确保同一时间只有一个指针指向该资源。这既安全又高效，适用于不需要共享资源的场景。

模拟实现要点：

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;
    
    T& operator*() { return *_ptr; }
    T* operator->() { return _ptr; }

private:
    T* _ptr;
};

std::shared_ptr

这是最常用的智能指针，通过引用计数实现资源共享。多个 shared_ptr 可以指向同一对象，当引用计数归零时，资源才会被释放。需要注意的是，shared_ptr 存在循环引用的风险，此时需搭配 weak_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;
    }
    
    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

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;
    }
    
    T* get() const { return _ptr; }

private:
    T* _ptr;
};

删除定制器

在使用智能指针时，可能会遇到 new[] 或 malloc 出来的空间，直接用 delete 会导致未定义行为。此时需要自定义删除器（Deleter）。标准库的 unique_ptr 和 shared_ptr 都支持传入自定义删除函数，例如用 std::vector 的析构逻辑来清理数组。

总结

掌握智能指针的关键在于理解所有权模型：unique_ptr 独占，shared_ptr 共享，weak_ptr 辅助打破循环。在实际编码中，优先使用 unique_ptr，仅在必要时使用 shared_ptr，并时刻警惕循环引用陷阱。