template<class T>
class new_shared_ptr {
public：
    new_shared_ptr();
    new_shared_ptr(const new_shared_ptr& p);                 //构造
 
	~new_shared_ptr();                                       //析构
 
	new_shared_ptr& operator=(const 			new_shared_ptr<T>& obj);  //拷贝运算符
 
	new_shared_ptr(new_shared_ptr&& dying_obj);             // 移动构造
 
	new_shared_ptr& operator=(new_shared_ptr&& dying_obj);  //移动赋值运算符

	int operator->();        //->运算符

	int operator*();         //* 运算符
private:
    T* ptr;
    int* ref_count;
    mutex *m_pMutex;
}

new_shared_ptr(): ptr(new T), ref_count(new int(1)), mutex(new mutex) {}

new_shared_ptr(const new_shared_ptr& p) {
    //先对当前对象进行初始化
    ptr = p.ptr;
    ref_count = p.ref_count;
    mutex = p.mutex;
    //判断拷贝进来的指针是否指向空，不指向空表明当前地址多了一个指向，引用计数加一
    if (p.ptr != nullptr) {
        m_pMutex->lock();
        (*ref_count)++;
        m_pMutex->unlock();
    }
}
 

new_shared_ptr& operator=(const new_shared_ptr<T>& obj) {
    //检查自赋值
    if (obj.ptr == ptr) return *this;
    //防止空指针指向别处
    if (ptr) {
        //自身指向即将改变，判断原先指向的地址是否销毁
        m_pMutex->lock();
        (*ref_count)--;
        m_pMutex->unlock();
        if (*ref_count == 0) {
            delete ptr;
            delete ref_count;
            delete m_pMutex;
        }
        ptr = obj.ptr;
        ref_count = obj.ref_count;
        m_pMutex = obj.m_pMutex;
        m_pMutex->lock();
        (*ref_count)++;
        m_pMutex->unlock();
    }
    return *this;
}
T* operator->() return ptr;
T& operator*() return *ptr;

new_shared_ptr(new_shared_ptr&& dying_obj)
      : ptr(nullptr), ref_count(nullptr) {
  // 初始化后，调用swap，交换指针和引用计数，相当于清除了原有的shared_ptr，把它们都置为nullptr了
    dying_obj.swap(*this);
  }

  void swap(new_shared_ptr& other) {
    std::swap(ptr, other.ptr);
    std::swap(ref_count, other.ref_count);
  }

new_shared_ptr& operator=(new_shared_ptr&& dying_obj) {
    /* 创建一个临时变量，将待移动的智能指针转移到临时变量 */
    new_shared_ptr(std::move(dying_obj)).swap(*this);
    return *this;
  }

~new_shared_ptr() {
    if (!ptr || (*ref_count == 1)) {
        delete ptr;
        delete m_pMutex;
        delete ref_count;
    } else {
        m_pMutex->lock();
        (*ref_count)--;
        m_pMutex->unlock();
    }
}

#include <iostream>
using namespace std;

// 示例用类：Type，仅包含一个整数成员变量
class Type
{
public:
    int a = 1;
};

// 引用计数类，用于管理资源的引用数量
class share_count {
public:
    // 构造函数，初始化引用计数为 1（表示首次拥有资源）
    share_count() : _count(1) {}

    // 增加引用计数
    void add_count() {
        ++_count;
    }

    // 减少引用计数，并返回当前引用计数
    long reduce_count() {
        return --_count;
    }

    // 获取当前引用计数
    long get_count() const {
        return _count;
    }

private:
    long _count;  // 当前引用计数
};

// 智能指针类模板，模仿 shared_ptr 实现
template<typename T>
class smart_ptr
{
public:
    // 构造函数：接受一个原始指针参数
    // 如果传入非空指针，则初始化引用计数对象
    smart_ptr(T* ptr = NULL) : m_ptr(ptr), m_share_count(nullptr) {
        if (ptr) {
            m_share_count = new share_count;
        }
    }

    // 析构函数：如果引用计数为 0，则释放资源
    ~smart_ptr() {
        if (m_ptr && m_share_count && m_share_count->reduce_count() == 0) {
            delete m_ptr;           // 释放资源对象
            delete m_share_count;   // 释放引用计数对象
            cout << "~smart_ptr" << endl;  // 输出析构提示
        }
    }

    // 解引用操作符：返回对象引用
    T& operator*() const { return *m_ptr; }

    // 成员访问操作符：返回原始指针
    T* operator->() const { return m_ptr; }

    // 布尔类型转换：用于判断指针是否为空
    operator bool() const { return m_ptr != nullptr; }

    // 拷贝构造函数：共享资源，增加引用计数
    smart_ptr(const smart_ptr& rhs) noexcept {
        m_ptr = rhs.m_ptr;
        m_share_count = rhs.m_share_count;
        if (m_ptr) {
            m_share_count->add_count();
        }
    }

    // 拷贝赋值运算符：先释放自身管理的资源，再共享 rhs 的资源
    smart_ptr& operator=(const smart_ptr& rhs) noexcept {
        if (this != &rhs) { // 避免自我赋值
            // 如果当前持有的资源引用计数减为0，释放资源
            if (m_ptr && m_share_count && m_share_count->reduce_count() == 0) {
                delete m_ptr;
                delete m_share_count;
            }
            // 共享新资源并增加引用计数
            m_ptr = rhs.m_ptr;
            m_share_count = rhs.m_share_count;
            if (m_ptr) {
                m_share_count->add_count();
            }
        }
        return *this;
    }

    // 返回当前引用计数
    long use_count() const {
        if (m_ptr && m_share_count) {
            return m_share_count->get_count();
        }
        return 0;
    }

private:
    T* m_ptr;  // 原始指针，指向实际资源
    share_count* m_share_count;  // 引用计数对象
};