智能指针——shared_ptr的原理及仿写

shared_ptr的原理及仿写

• 共享指针允许多个指针指向同一份数据，因为它使用了引用计数，每多一个指针指向这个数据，引用技术加一，每销毁一个指针，引用技术减一，如果引用计数为0，则delete这个数据。
• 但是共享指针也不能将同一个裸指针赋值给多个智能指针，因为这样会是两个独立的共享指针，它们会分别计数，也就是意味着到时候它们会重复释放。
• 第一个没有计数器设计的版本：

template<typename T>
class MyShared_ptr {
private:
    //内部指针
    T* m_ptr;
    //计数器
    long* m_count;
public:
    //以裸指针构造共享指针，默认为nullptr
    //禁止隐式构造
    explicit MyShared_ptr(T* ptr = nullptr) : m_ptr(ptr) {
        //计数器初始化为1
        m_count = new long(1);
    }
    //以MyUnique_ptr右值构造共享指针
    MyShared_ptr(MyUnique_ptr<T>&& src) {
        //销毁独占指针，取出裸指针
        m_ptr = src.release();
        //计数器初始化为1
        m_count = new long(1);
    }
    //拷贝构造函数
    MyShared_ptr(const MyShared_ptr& src) {
        m_ptr = src.m_ptr;
        //拷贝计数器指针
        m_count = src.m_count;
        //计数器加一
        (*m_count)++;
    }
    //拷贝赋值
    MyShared_ptr& operator=(const MyShared_ptr& src) {
        if (&src == this) return *this;
        //如果自身不为空，先调用析构函数
        if (m_ptr != nullptr) {
            this->~MyShared_ptr();
        }
        m_ptr = src.m_ptr;
        m_count = src.m_count;
        (*m_count)++;
        return *this;
    }
    //以MyUnique_ptr右值 拷贝赋值
    MyShared_ptr& operator=(const MyUnique_ptr<T>&& src) {
        if (m_ptr != nullptr) {
            this->~MyShared_ptr();
        }
        //销毁独占指针，取出裸指针
        m_ptr = src.release();
        m_count = new long(1);
        return *this;
    }
    //析构函数
    ~MyShared_ptr() {
        //计数器减一
        (*m_count)--;
        //如果计数器为0，则释放指针空间和计数器空间
        if (0 == *m_count) {
            delete m_ptr;
            delete m_count;
            m_ptr = nullptr;
            m_count = nullptr;
        }
    }
    //获得内部指针地址
    T* get() {
        return m_ptr;
    }
    //重置指针
    void reset(T* ptr = nullptr) {
        //先调用析构函数
        this->~MyShared_ptr();
        m_ptr = ptr;
        m_count = new long(1);
    }
    //返回当前引用计数
    long use_count() {
        return *m_count;
    }
    //转换函数 bool
    operator bool() const {
        return m_ptr != nullptr;
    }
    //当前共享指针是否唯一
    bool unique() {
        if (1 == *m_count) return true;
        else return false;
    }
    //成员函数交换指针和计数器
    void swap(MyShared_ptr<T>& src) {
        T* temp_ptr;
        long* temp_count;
        temp_ptr = src.m_ptr;
        temp_count = src.m_count;
        src.m_ptr = m_ptr;
        src.m_count = m_count;
        m_ptr = temp_ptr;
        m_count = temp_count;
    }
    //重载*
    T& operator*() const {
        return *m_ptr;
    }
    //重载->
    T* operator->() const {
        return (&**this);
    }
};
//全局函数，有右值引用make_MyShared
template<class T>
MyShared_ptr<T> make_MyShared(MyShared_ptr<T>&& src) {
    return MyShared_ptr<T>(forward<MyShared_ptr<T>>(src));
}

• 有计数器设计的版本

//计数器设计
template<typename T>
class MyCount {
private:
    //分别存储引用计数和弱指针计数
    long use_count;
    long weak_count;
public:
    //计数器的初始化
    MyCount(long u,long w) : use_count(u), weak_count(w) {}
    //弱指针计数++
    void Increase_weak_count() {
        ++weak_count;
    }
    //弱指针计数--
    void Decrease_weak_count() {
        --weak_count;
    }
    //引用计数++
    void Increase_use_count() {
        ++use_count;
    }
    //引用计数--
    void Decrease_use_count() {
        --use_count;
    }
    //获得引用计数
    long get_use_count() {
        return use_count;
    }
    //释放传入对象的内存
    void DestroyPtr(T* ptr) {
        delete ptr;
    }
    //若没有弱指针，则释放计数器
    void DestroyThis() {
        if(0 == weak_count)
            delete this;
    }
};

template<typename T>
class MyShared_ptr {
private:
    //内部指针
    T* m_ptr;
    //计数器指针
    MyCount<T>* m_count;
public:
    //以裸指针构造共享指针
    explicit MyShared_ptr(T* ptr = nullptr) : m_ptr(ptr) {
        //初始化计数器为 引用1 弱指针0
        m_count = new MyCount<T>(1,0);
    }
    //以独占指针构造共享指针
    MyShared_ptr(MyUnique_ptr<T>&& src) {
        //销毁独占指针并取出裸指针
        m_ptr = src.release();
        //初始化计数器为 引用1 弱指针0
        m_count = new MyCount<T>(1, 0);
    }
    //拷贝构造
    MyShared_ptr(const MyShared_ptr& src) {
        m_ptr = src.m_ptr;
        m_count = src.m_count;
        //引用计数++
        m_count->Increase_use_count();
    }
    //拷贝赋值
    MyShared_ptr& operator=(const MyShared_ptr& src) {
        if (&src == this) return *this;
        if (m_ptr != nullptr) {
            this->~MyShared_ptr();
        }
        m_ptr = src.m_ptr;
        m_count = src.m_count;
        //引用计数++
        m_count->Increase_use_count();
        return *this;
    }
    //拷贝独占指针赋值
    MyShared_ptr& operator=(const MyUnique_ptr<T>&& src) {
        if (m_ptr != nullptr) {
            this->~MyShared_ptr();
        }
        m_ptr = src.release();
        m_count = new MyCount<T>(1, 0);
        return *this;
    }
    //析构函数
    ~MyShared_ptr() {
        //引用计数--
        m_count->Decrease_use_count();
        //如果引用计数为零
        if (0 == m_count->get_use_count()) {
            //释放指针
            m_count->DestroyPtr(m_ptr);
            //销毁计数器（计数器内部判断有无弱指针）
            m_count->DestroyThis();
            m_ptr = nullptr;
            m_count = nullptr;
        }
    }
    //获得内部指针地址
    T* get() {
        return m_ptr;
    }
    //重置共享指针为新指针
    void reset(T* ptr = nullptr) {
        this->~MyShared_ptr();
        m_ptr = ptr;
        m_count = new MyCount<T>(1, 0);
    }
    //返回引用计数
    long use_count() {
        return m_count->get_use_count();
    }
    //转换函数
    operator bool() const {
        return m_ptr != nullptr;
    }
    //是否唯一
    bool unique() {
        if (1 == m_count->get_use_count()) return true;
        else return false;
    }
    //交换指针和计数器
    void swap(MyShared_ptr<T>& src) {
        T* temp_ptr;
        MyCount<T>* temp_count;
        temp_ptr = src.m_ptr;
        temp_count = src.m_count;
        src.m_ptr = m_ptr;
        src.m_count = m_count;
        m_ptr = temp_ptr;
        m_count = temp_count;
    }
    //重载*
    T& operator*() const {
        return *m_ptr;
    }
    //重载->
    T* operator->() const {
        return (&**this);
    }
    //设置弱指针类为友元类
    template<typename T>
    friend class MyWeak_ptr;
};

//全局函数，有右值引用make_MyShared
template<class T>
MyShared_ptr<T> make_MyShared(MyShared_ptr<T>&& src) {
    return MyShared_ptr<T>(forward<MyShared_ptr<T>>(src));
}