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

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

class CPoint
{
  public:
    CPoint(int xVal = 0, int yVal = 0) : 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(1) {}
    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 = 0;
        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-- == 0)
        {
            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 = 0, int yVal = 0) : 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(1){}
        ~CCountPtr()
        {
            m_count=0;
        }
};

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  = 0;
          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-- == 0)
          {
              delete m_pCountPtr;
              m_pCountPtr = nullptr;
          }
          else
          {
              cout << "引用次数:" << m_pCountPtr->m_count << endl;
          }
      }
      CCountPtr *m_pCountPtr;
};

int main()
{
    CPoint *pPoint = new CPoint(3,4);
    {
        CSmartPtr sptr1(pPoint);
        {
            (*sptr1).setX(10);
            cout<<"initial:"<<endl;
            cout << "sptr1->getX(): " << sptr1->getX() << endl;
            CPoint *pPoint2 = new CPoint(5, 6);
            /*测试swap*/
            cout << "swap:" << endl;
            CPoint *pPoint4 = new CPoint(30, 40);
            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(30, 40);
            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 0;
}

       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(1) {}
        ~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 = 0;
          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-- == 0)
          {
              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=10;
    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>(20);
            cout << "*sptr3: " << *sptr3 << endl;
        }
        cout<<"sptr1.count: "<< sptr1.user_count()<<endl;
    }

    system("pause");
    return 0;
}

以上为智能指针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/