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:
    T* _ptr;
};

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

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;
    std::function<void(T*)> _del = [](T* ptr) { delete ptr; };
};

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

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

删除定制器

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

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

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