C++——智能指针unique_ptr的实现

1. 起初，我最直观的设计想法，直接设计一个类：包含全部要素（对象，指针计数）。然后提供出去。

 class CPoint
 {
   public:
     CPoint(int xVal = , int yVal = ) : x(xVal), y(yVal) {}
     int getX() const { return x; }
     int getY() const { return y; }
     void setX(int xVal) { x = xVal; }
     void setY(int yVal) { y = yVal; }

   private:
     int x, y;
 };

 class CSmartPtr
 {
   public:
     CSmartPtr(CPoint *ptr) : m_pPoint(ptr),m_count() {}
     CSmartPtr(const CSmartPtr &sptr) : m_pPoint(sptr.m_pPoint),m_count(sptr.m_count) {}

     ~CSmartPtr()
     {
         Release();
     }
     CPoint* get()
     {
         return m_pPoint;
     }
 /*此处不知道如何有效实现，既能提供出去，有把内部清空？？？？*/
     CPoint *release()
     {
         m_count = ;
         return m_pPoint;
     }
     int user_count() { return m_count; }
     CPoint &operator*()
     {
         return *(m_pPoint);
     }

     CPoint *operator->()
     {
         return m_pPoint;
     }

   private:
     void Release()
     {
         if (m_count-- == )
         {
             delete m_pPoint;
         }
         else
         {
             cout << "引用次数:" << m_count << endl;
         }
     }

     int m_count;
     CPoint *m_pPoint;
 };

但是我实现到release方法的时候，并不能满足需求。因为release方法的要求是，交出对象的控制权，然后智能指针指向null；Releases ownership of its stored pointer, by returning its value and replacing it with a null pointer.这就尴尬了。因此采用了将指针计数和对象单独拿出来的做法，也就是网上其他博客中常见的做法。但我还不是很理解他们那种做法的解释。

代码实现：

 class CPoint
 {
   public:
     CPoint(int xVal = , int yVal = ) : x(xVal), y(yVal) {}
     int getX() const { return x; }
     int getY() const { return y; }
     void setX(int xVal) { x = xVal; }
     void setY(int yVal) { y = yVal; }

   private:
     int x, y;
 };
 class CSmartPtr;
 /*

 */
 class CCountPtr
 {
     private:
         friend class CSmartPtr;
         int m_count;
         CPoint *m_pPoint;
         CCountPtr(CPoint *ptr):m_pPoint(ptr),m_count(){}
         ~CCountPtr()
         {
             m_count=;
         }
 };

 class CSmartPtr
 {
     public:
       CSmartPtr(CPoint *ptr) : m_pCountPtr (new CCountPtr(ptr)){}
       CSmartPtr(const CSmartPtr &sptr) : m_pCountPtr(sptr.m_pCountPtr) {}
       CSmartPtr& operator=(const CSmartPtr &sptr)
       {
           (sptr.m_pCountPtr->m_count)++;
           minusOne();
           m_pCountPtr = sptr.m_pCountPtr;
           return *this;
       }
       ~CSmartPtr()
       {
           minusOne();
       }
       CPoint *get()
       {
           return m_pCountPtr->m_pPoint;
       }
       CPoint *release()
       {
           CPoint *pRet = m_pCountPtr->m_pPoint;
           m_pCountPtr->m_pPoint = nullptr;
           m_pCountPtr->m_count  = ;
           return pRet;
       }
       /*Destroys the object currently managed by the unique_ptr (if any) and takes ownership of p.*/
       void reset(CPoint *pPoint)
       {
           minusOne();
           m_pCountPtr = new CCountPtr(pPoint);
       }
       void swap(CSmartPtr &x)
       {
           CPoint *pRet = m_pCountPtr->m_pPoint;
           int count = m_pCountPtr->m_count;

           m_pCountPtr->m_pPoint = x.m_pCountPtr->m_pPoint;
           m_pCountPtr->m_count = x.m_pCountPtr->m_count;

           x.m_pCountPtr->m_pPoint = pRet;
           x.m_pCountPtr->m_count = count;
       }

       int user_count(){return m_pCountPtr->m_count; }
       CPoint& operator *()
       {
           return *(m_pCountPtr->m_pPoint);
       }

       CPoint* operator ->()
       {
           return m_pCountPtr->m_pPoint;
       }

     private:
       void minusOne()
       {
           if (m_pCountPtr->m_count-- == )
           {
               delete m_pCountPtr;
               m_pCountPtr = nullptr;
           }
           else
           {
               cout << "引用次数:" << m_pCountPtr->m_count << endl;
           }
       }
       CCountPtr *m_pCountPtr;
 };

 int main()
 {
     CPoint *pPoint = new CPoint(,);
     {
         CSmartPtr sptr1(pPoint);
         {
             (*sptr1).setX();
             cout<<"initial:"<<endl;
             cout << "sptr1->getX(): " << sptr1->getX() << endl;
             CPoint *pPoint2 = new CPoint(, );
             /*测试swap*/
             cout << "swap:" << endl;
             CPoint *pPoint4 = new CPoint(, );
             CSmartPtr sptr2(pPoint4);
             sptr1.swap(sptr2);
             cout << "sptr1->getX(): " << sptr1->getX() << endl;
             cout << "sptr2->getX(): " << sptr2->getX() << endl;
             /*测试reset*/
             cout << "reset:" << endl;
             sptr1.reset(pPoint2);
             cout << "sptr1->getX(): " << sptr1->getX() << endl;
             /*测试release*/
             cout << "release:" << endl;
             CPoint *pPoint3 = new CPoint(, );
             pPoint3 = sptr1.release();
             cout << "pPoint3->getX(): " << pPoint3->getX() << endl;
             cout << "sptr1.count: " << sptr1.user_count() << endl;
         }
         cout<<"sptr1.count: "<< sptr1.user_count()<<endl;
     }

     cout<<"pPoint.getx(): "<<pPoint->getX()<<endl;
     system("pause");
     return ;
 }

2.模板类。改进一下即可。将CPoint换成泛型表达。

 template <typename T>
 class CSmartPtr;

 template <typename T>
 class CCountPtr
 {
     private:
         friend class CSmartPtr<T>;
         int m_count;
         T *m_pT;
         CCountPtr(T *ptr) : m_pT(ptr), m_count() {}
         ~CCountPtr(){}
 };

 template <typename T>
 class CSmartPtr
 {
     public:
       CSmartPtr(T *ptr) : m_pCountPtr (new CCountPtr<T>(ptr)){}
       CSmartPtr(const CSmartPtr &sptr) : m_pCountPtr(sptr.m_pCountPtr) {}
       CSmartPtr& operator=(const CSmartPtr &sptr)
       {
           (sptr.m_pCountPtr->m_count)++;
           minusOne();
           m_pCountPtr = sptr.m_pCountPtr;
           return *this;
       }

       ~CSmartPtr()
       {
           minusOne();
       }
       T * get()
       {
           return m_pCountPtr->m_pPoint;
       }
       T *release()
       {
           T *pRet = m_pCountPtr->m_pPoint;
           m_pCountPtr->m_pPoint = nullptr;
           m_pCountPtr->m_count = ;
           return pRet;
       }
       /*Destroys the object currently managed by the unique_ptr (if any) and takes ownership of p.*/
       void reset(T *pPoint)
       {
           minusOne();
           m_pCountPtr = new CCountPtr<T>(pPoint);
       }
       void swap(CSmartPtr &x)
       {
           T *pRet = m_pCountPtr->m_pPoint;
           int count = m_pCountPtr->m_count;

           m_pCountPtr->m_pPoint = x.m_pCountPtr->m_pPoint;
           m_pCountPtr->m_count = x.m_pCountPtr->m_count;

           x.m_pCountPtr->m_pPoint = pRet;
           x.m_pCountPtr->m_count = count;
       }

       int user_count(){return m_pCountPtr->m_count; }

       T& operator *()
       {
           return *(m_pCountPtr->m_pT);
       }

       T* operator ->()
       {
           return m_pCountPtr->m_pT;
       }

     private:
       void minusOne()
       {
           if (m_pCountPtr->m_count-- == )
           {
               delete m_pCountPtr;
               m_pCountPtr = nullptr;
           }
           else
           {
               cout << "引用次数:" << m_pCountPtr->m_count << endl;
           }
       }
       CCountPtr<T> *m_pCountPtr;
 };

 /*这里使用了参数包，我对此不是很熟悉，直接copy的代码*/
 template<typename T, typename... Args>
 inline CSmartPtr<T>
 make_smart(Args&&... args)
 {
     return CSmartPtr<T>(new T(std::forward<Args>(args)...));
 }

 int main()
 {
     int b=;
     int* a=&b;
     {
         CSmartPtr<int> sptr1(a);
         {
             cout << "*sptr1: " << *sptr1 << endl;
             CSmartPtr<int> sptr2 = sptr1;

             cout << "*sptr2: " << *sptr2 << endl;

             CSmartPtr<int> sptr3 = make_smart<int>();
             cout << "*sptr3: " << *sptr3 << endl;
         }
         cout<<"sptr1.count: "<< sptr1.user_count()<<endl;
     }

     system("pause");
     return ;
 }

以上为智能指针shared_ptr的实现过程，还是有很多东西要学习的。

以下为参考网站，以至于很多东西都是直接拿过来的，感谢！

https://www.cnblogs.com/QG-whz/p/4777312.html

http://www.cplusplus.com/reference/memory/unique_ptr/unique_ptr/

https://liam.page/2018/01/13/smart-pointer/