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

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(unique_ptr<T>& ap) = delete;
    unique_ptr<T>& operator=(unique_ptr<T>& ap) = delete;
    // 除了这种办法：还能 private 这个成员函数，并且只声明不实现
private:
    T* _ptr;
};
// 使用：unique_ptr<A>up1(new A(5));

引申：一般拷贝不让实现的话，赋值也不能实现——就像上面禁止就一起禁止了。

std::shared_ptr

这个智能指针是最全面的——一般都是用的这个，然后有循环引用的时候搭配 weak_ptr 用。

也是 RAII 思想实现的。

原理：通过引用计数的方式来实现多个 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) {
            delete _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 不能管理资源！！！

注意：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& operator*() { return *_ptr; }
    T* operator->() { return _ptr; }
private:
    T* _ptr;
};
// weak_ptr 其实也是可以转换成 shared_ptr 的，只是自己没有实现罢了

删除定制器

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

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

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