智能指针（shared_ptr）简易实现

使用模板类简易实现shared_ptr功能，使用指针记录引用计数。

template<typename T>
class MyPtr{
private:
    T *m_p;                //智能指针保存的对象指针
    int *m_count;        //智能指针计数器
public:

//构造函数
    MyPtr() : m_p(nullptr), m_count(nullptr) {}        

    explicit MyPtr(T* val){
        this->m_p = val;
        this->m_count = nullptr;
        if(val) this->m_count = new int(1);
    }

    explicit MyPtr(const MyPtr& myPtr){
        this->m_p = myPtr.m_p;
        this->m_count = myPtr.m_count;
        if(this->m_count) ++*(this->m_count);
    }

    ~MyPtr(){
        reset();
    }

//reset函数使该智能指针放弃所指向的内容，同时计数器减一；如果该指针是唯一指向对象的指针则释放对象的内存 

    void reset(){
        if(m_count){
            --*m_count;
            if(*m_count == 0){
                delete(m_p);
                delete(m_count);
            }
        }
        m_p = nullptr;
        m_count = nullptr;
    }

//swap函数交换两个智能指针 

    MyPtr& swap(MyPtr& myPtr){
        T *tmp = myPtr.m_p;
        myPtr.m_p = this->m_p;
        this->m_p = tmp;

        int *tmpCount = myPtr.m_count;
        myPtr.m_count = this->m_count;
        this->m_count = tmpCount;

        return *this;
    }

    T* get(){
        return m_p;
    }

//重载运算符

    T& operator*(){
        return *m_p;
    }

    T* operator->(){
        return m_p;
    }

    MyPtr& operator=(const MyPtr& myPtr){
        if(this == &myPtr) return *this;

        reset();
        this->m_p = myPtr.m_p;
        this->m_count = myPtr.m_count;
        if(myPtr.m_count){
            ++*(myPtr.m_count);
        }
    }

//显示计数器的值 

    int showCount(){
        return m_count? *m_count : 0;
    }

    bool isUnique(){
        return m_count? *m_count == 1 : false;
    }
};