unique_ptr和shared_ptr智能指针的实现

unique_ptr

template<typename T>
class MyUP {
public:
       explicit MyUP(T* ptr = nullptr)
              :_ptr(ptr){
       }
       ~MyUP() {
              if(_ptr)
                  delete _ptr;
       }
       MyUP(const MyUP& myUp) = delete;
       MyUP& operator = (const MyUP& myUp) = delete;
       MyUP(MyUP&& myUp):_ptr(myUp._ptr) {
              myUp._ptr = nullptr;
       }
       MyUP<T>& operator = (MyUP&& myUp) {
              if (myUp == *this)
                     return *this;
              if (_ptr)
                     delete _ptr;
              _ptr = myUp._ptr;
              myUp._ptr = nullptr;
              return *this;
       }
       T& operator * () const { return  *_ptr; }
       T* operator -> () const { return  _ptr; }
private:
       T* _ptr;
};

shared_ptr

template <typename T>
class ShaPtr
{
public:
       ShaPtr(T* ptr = nullptr)
              :_ptr(ptr),
              _count(new int(1)) {}
        //因为构造函数中引用计数被初始化为1，所以析构时判断引用计数为1就释放资源。
       ~ShaPtr(){
              if (*_count == 1) {
                     delete _ptr;
                     _ptr = nullptr;
                     delete _count;
                     _count = nullptr;
              }
              else {
                     --(*_count);
              }
       }
       ShaPtr(const ShaPtr& shaPtr):_ptr(shaPtr._ptr),_count(shaPtr._count) {
              ++(*_count);
       }
       ShaPtr& operator = (const ShaPtr& shaPtr) {
              if (shaPtr != *this) {
                     if (_count == 1) {
                           delete _ptr;
                           delete _count;
                     }
                     _ptr = shaPtr._ptr;
                     _count = shaPtr._count;
                     ++(*_count);
              }
              return *this;
       }
       T& operator*()const { return *_ptr; }
       T* operator->()const { return _ptr };
private:
       T* _ptr;
       int* _count;
};