C++ 智能指针详解：原理、模拟实现与使用场景

template <class T>
class auto_ptr {
public:
    auto_ptr(T* ptr) : _ptr(ptr) {}
    ~auto_ptr() { delete _ptr; }
    T& operator*() { return *_ptr; }
    T* operator->() { return _ptr; }
    
    // 拷贝构造函数，转移所有权
    auto_ptr(auto_ptr<T>& ap) : _ptr(ap._ptr) { 
        ap._ptr = nullptr; 
    }
    
    // 赋值运算符也会转移所有权
    auto_ptr& operator=(auto_ptr<T>& ap) {
        if (this != &ap) {
            delete _ptr;
            _ptr = ap._ptr;
            ap._ptr = nullptr;
        }
        return *this;
    }
private:
    T* _ptr;
};

std::unique_ptr

unique_ptr, shared_ptr 和 weak_ptr 是 Boost 库先实现的，后来 C++11 也支持这几个智能指针的使用了。

unique_ptr 直接让智能指针不能拷贝和赋值，且不支持管理权转移（除非显式移动）。这个智能指针也是基于 RAII 思想实现的。

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;
    
    // 允许移动
    unique_ptr(unique_ptr<T>&& other) noexcept : _ptr(other._ptr) {
        other._ptr = nullptr;
    }
    unique_ptr& operator=(unique_ptr<T>&& other) noexcept {
        if (this != &other) {
            delete _ptr;
            _ptr = other._ptr;
            other._ptr = nullptr;
        }
        return *this;
    }
private:
    T* _ptr;
};

引申：一般拷贝不让实现的话，赋值也不能实现。

std::shared_ptr

这个智能指针是最全面的，一般都是用的这个，然后有循环引用的时候搭配 weak_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;
    function<void(T*)> _del = [](T* ptr){ delete ptr; };
};

用法：

shared_ptr<A> sp1(new A(1));

注意：shared_ptr<A> 跟 A 可不是一个类型。

编译器对越界访问的检查一般不是很彻底的。

shared_ptr 的一个弊端

shared_ptr 在遇到循环引用的时候也是会内存泄漏的。

std::weak_ptr

weak_ptr 这个智能指针不是 RAII 思想的，它的唯一作用就是解决 shared_ptr 的循环引用问题的。

这个智能指针可以访问资源，但是不参与资源释放的解决。

注意：weak_ptr 库里面实现了让它可以和 shared_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;
    }
    
    T* get() const { return _ptr; }
private:
    T* _ptr;
};

删除定制器

在智能指针使用过程中，可能会有 new[] 或者 malloc 出来的空间，这些空间用 delete 根本不行，此时就需要删除定制器了。

库里面的话，是给 unique_ptr 和 shared_ptr 配备了删除定制器的。

这里的话，自己模拟实现一下 shared_ptr 的删除定制器（在上面的模拟实现里面已经写了）。

总结

掌握智能指针是安全 C++ 开发的关键。根据所有权需求选择 unique_ptr 或 shared_ptr，配合 weak_ptr 避免循环引用，并使用自定义删除器处理特殊内存分配，能有效杜绝内存泄漏。