c++ SharedPtr 源码简化实现

shared_ptr 本质是是一个模板类，从模板类的角度，简单了解智能指针的实现思想，更好的使用智能指针。记录下简单实现的模板。

template<typename T>
class SharedPtr {
private:
    T* ptr;           // 实际指向对象的指针
    std::size_t* ref_count; // 引用计数的指针

public:
    // 默认构造函数
    explicit SharedPtr(T* p = nullptr) : ptr(p), ref_count(new std::size_t(1)) {}

    // 拷贝构造函数
    SharedPtr(const SharedPtr<T>& sp) : ptr(sp.ptr), ref_count(sp.ref_count) {
        ++(*ref_count);
    }

    // 移动构造函数
    SharedPtr(SharedPtr<T>&& sp) noexcept : ptr(sp.ptr), ref_count(sp.ref_count) {
        sp.ptr = nullptr;
        sp.ref_count = nullptr;
    }

    // 赋值运算符
    SharedPtr<T>& operator=(const SharedPtr<T>& sp) {
        if (this != &sp) {
            if (--(*ref_count) == 0) {
                delete ptr;
                delete ref_count;
            }
            ptr = sp.ptr;
            ref_count = sp.ref_count;
            ++(*ref_count);
        }
        return *this;
    }

    // 移动赋值运算符
    SharedPtr<T>& operator=(SharedPtr<T>&& sp) noexcept {
        if (this != &sp) {
            if (--(*ref_count) == 0) {
                delete ptr;
                delete ref_count;
            }
            ptr = sp.ptr;
            ref_count = sp.ref_count;
            sp.ptr = nullptr;
            sp.ref_count = nullptr;
        }
        return *this;
    }

    // 解引用操作符
    T& operator*() const {
        return *ptr;
    }

    // 成员访问操作符
    T* operator->() const {
        return ptr;
    }

    // 返回裸指针
    T* get() const {
        return ptr;
    }

    // 返回引用计数
    std::size_t use_count() const {
        return *ref_count;
    }

    // 判断是否唯一
    bool unique() const {
        return *ref_count == 1;
    }

    // 重置指针
    void reset(T* p = nullptr) {
        if (--(*ref_count) == 0) {
            delete ptr;
            delete ref_count;
        }
        ptr = p;
        ref_count = new std::size_t(1);
    }

    // 析构函数
    ~SharedPtr() {
        if (--(*ref_count) == 0) {
            delete ptr;
            delete ref_count;
        }
    }