设计shared_ptr

my_shared_ptr.h#

#include <iostream>
#include <atomic>

template<typename T>
class my_shared_ptr {
private:
    T* m_ptr = nullptr;
    unsigned int* ref_count = nullptr;
    void swap(my_shared_ptr&);
public:
    my_shared_ptr() :m_ptr(nullptr), ref_count(nullptr) {};
    my_shared_ptr(T* ptr) :m_ptr(ptr), ref_count(new unsigned int(1)) {};
    ~my_shared_ptr()
    {
        if (ref_count == nullptr)
        {
            return;
        }
        (*ref_count)--;
        if (*ref_count > 0)
        {
            return;
        }

        if (m_ptr != nullptr)
        {
            m_ptr = nullptr;
        }
        delete ref_count;
    }
    //复制构造函数
    my_shared_ptr(const my_shared_ptr& obj) {
        m_ptr = obj.m_ptr;
        ref_count = obj.ref_count;
        if (ref_count != nullptr) {
            (*ref_count)++;
        }
    }
    //赋值运算符
    my_shared_ptr& operator=(const my_shared_ptr& obj) {
        if (obj.m_ptr == m_ptr) {
            return *this;
        }
        if (ref_count != nullptr) {
            if (*ref_count == 0) {
                delete ref_count;
                delete m_ptr;
            }
        }
        m_ptr = obj.m_ptr;
        ref_count = obj.ref_count;
        if (ref_count != nullptr) {
            (*ref_count)++;
        }
        return *this;
    }
    //移动构造函数
    my_shared_ptr(my_shared_ptr&& obj) :m_ptr(nullptr), ref_count(nullptr) {
        printf("移动构造\n");
        obj.swap(*this);
    }
    //移动赋值运算符
    my_shared_ptr& operator=(my_shared_ptr&& obj){
        printf("移动赋值\n");
        my_shared_ptr(std::move(obj)).swap(*this);
        return *this;
    }
    //工具函数
    unsigned int use_count() const{
        return ref_count != nullptr ? *ref_count : 0;
    }
};

template<typename T>
void my_shared_ptr<T>::swap(my_shared_ptr& obj) {
    std::swap(m_ptr, obj.m_ptr);
    std::swap(ref_count, obj.ref_count);
}

my_shared_ptr.cpp#

#include <iostream>
#include "my_shared_ptr.h"

int main()
{
    //有参构造函数
    int* ptr = new int(100);
    my_shared_ptr<int> p2(ptr);
    std::cout << "有参构造p2  use_count() = " << p2.use_count() << std::endl;
    //复制构造函数
    my_shared_ptr<int> p3(p2);
    std::cout << "复制构造p3  use_count() = " << p3.use_count() << std::endl;
    //赋值运算符
    p3 = p2;
    std::cout << "p3  use_count() = " << p3.use_count() << std::endl;
    std::cout << "p2  use_count() = " << p2.use_count() << std::endl;
    //移动复制
    my_shared_ptr<int> p4(p3);
    std::cout << "p4  use_count() = " << p4.use_count() << std::endl;
    my_shared_ptr<int> p5(std::move(p4));
    std::cout << "p4  use_count() = " << p4.use_count() << std::endl;
    std::cout << "p5  use_count() = " << p5.use_count() << std::endl;
    //移动赋值
    p4 = std::move(p5);
    std::cout << "p5  use_count() = " << p5.use_count() << std::endl;
    std::cout << "p4  use_count() = " << p4.use_count() << std::endl;


}

> 结果：