从C语言到C++_36(智能指针RAII)auto_ptr+unique_ptr+shared_ptr+weak_ptr（中）

从C语言到C++_36(智能指针RAII)auto_ptr+unique_ptr+shared_ptr+weak_ptr（上）：https://developer.aliyun.com/article/1522495

3.1 auto_ptr模拟代码

（上面SmartPtr再加一个赋值重载改下名字就差不多是auto_ptr的模拟了，再用命名空间封一下）

赋值重载细节还挺多的，前面学的赋值重载都类似拷贝构造，可以不看先写写，这里直接放代码：

#include <iostream>
#include <memory>
using namespace std;
//1、RAII
//2、像指针一样
//3、解决拷贝问题（不同的智能指针的解决方式不一样）
 
namespace rtx
{
  template<class T>
  class auto_ptr
  {
  public:
    auto_ptr(T* ptr)
      :_ptr(ptr)
    {}
    ~auto_ptr()
    {
      cout << "~auto_ptr -> delete: " << _ptr << endl;
      delete _ptr;
    }
    auto_ptr(auto_ptr<T>& ptr)
      :_ptr(ptr._ptr)
    {
      ptr._ptr = nullptr;
    }
    auto_ptr<T>& operator=(auto_ptr<T>& ap)
    {
      if (this != &ap) // 防止自己赋值给自己
      {
        if (_ptr) // 防止释放空，delete空也行
        {
          cout << "operator= -> Delete:" << _ptr << endl;
          delete _ptr;
        }
        _ptr = ap._ptr;
        ap._ptr = nullptr;
      }
      return *this;
    }
 
    T& operator*()
    {
      return *_ptr;
    }
 
    T* operator->()
    {
      return _ptr;
    }
  protected:
    T* _ptr;
  };
}
 
class A
{
public:
  ~A()
  {
    cout << "~A()" << endl;
  }
//protected:
  int _a1 = 0;
  int _a2 = 0;
};
 
int main()
{
  //SmartPtr<A> sp1(new A);
  //SmartPtr<A> sp2(sp1);
  rtx::auto_ptr<A> sp1(new A);
  rtx::auto_ptr<A> sp2(sp1);
  rtx::auto_ptr<A> sp3 = sp2;
 
  return 0;
}

       可以把命名空间切换到std比较一下，auto_ptr使用的是管理权转移的办法，会导致被拷贝对象悬空，是不负责的拷贝，对于不清楚auto_ptr这个特点的人来说，拷贝后再次使用ap1就会出问题。auto_ptr是C++98一个失败的设计，被挂在了耻辱柱上，很多公司明确要求不能使用auto_ptr。

       C++98至C++11期间人们被迫用C++更新探索的库：boost库里的一些智能指针，到了C++11，终于更新了三个智能指针：unique_prt，shared_ptr，wead_ptr，相当于抄boost库的作业了。下面我们介绍以及模拟实现这几个智能指针，当然，还有很多接口在模拟代码里没有实现。

4. unique_ptr

在C++11中更加靠谱的unique_ptr智能指针：

unique_ptr直接禁止使用拷贝构造函数，即使编译器也不能生成默认的拷贝构造函数，因为使用了delete关键字。

       unique_ptr采用的策略就是，既然拷贝有问题，那么就直接禁止拷贝，这确实解决了悬空等问题，使得unique_ptr是一个独一无二的智能指针。

（写到这发现忘记创建新项目了，这里创建一个Test.cpp和SmartPtr.hpp（.h+.cpp，直接.h也行，都可以把函数的实现在里面实现。声明和定义分离只是为了保护源码）

4.1 unique_ptr模拟代码

直接复制一份auto_ptr代码过来，用delete关键字禁言拷贝构造和赋值重载就行了：

  template<class T>
  class unique_ptr
  {
  public:
    unique_ptr(T* ptr)
      :_ptr(ptr)
    {}
    ~unique_ptr()
    {
      cout << "~unique_ptr -> delete: " << _ptr << endl;
      delete _ptr;
    }
    unique_ptr(unique_ptr<T>& ptr) = delete;
    unique_ptr<T>& operator=(unique_ptr<T>& ap) = delete;
 
    T& operator*()
    {
      return *_ptr;
    }
    T* operator->()
    {
      return _ptr;
    }
  protected:
    T* _ptr;
  };

关于delete关键字的复习链接：（在5.2）从C语言到C++_33(C++11_上)initializer_list+右值引用+完美转发+移动构造/赋值_GR_C的博客-CSDN博客

5. shared_ptr

unique_ptr禁掉了拷贝，但是如果我就想拷贝智能指针呢？这就要用到shared_ptr了：

        shared_ptr采用了引用计数的方法来解决拷贝问题：（引用计数直接在成员变量加一个int Count可以吗？每一个对象都有一个自己的Count显然是不对的，我们应该让拷贝和被拷贝对象管理同一个Count。那么使用静态成员变量可以吗？这也不可以，因为这样所有的对象都管理的是同一个Count了，包括没有拷贝的对象）

shared_ptr原理：

通过引用计数的方式来实现多个shared_ptr对象之间共享资源。

       例如：老师晚上在下班之前都会通知，让最后走的学生记得把门锁下。

① shared_ptr内部，给每个资源都维护了一份计数，用来记录该份资源被几个对象共享。

② 在对象被销毁时(也就是析构函数调用)，说明自己不使用该资源了，对象引用计数减一。

③ 如果引用计数是0，就说明自己是最后一个使用该资源的对象，必须释放该资源。

④ 如果不是0，就说明除了自己还有其他对象在使用该份资源，不能释放该资源，否则其他对象就成野指针了。

shared_ptr增加了一个成员类似int* _pCount解决这个问题：

这样构造，拷贝构造和析构函数就是这样的：

       构造先给 _pCount指向1，析构无论什么时候都减减，如果减减0就释放资源，拷贝构造就是把指针也给它，然后指针指向的内容加加。

到这可以自己尝试写一个赋值重载出来，手写或者敲都行OK，这里直接放代码了：

5.1 shared_ptr模拟代码

  template<class T>
  class shared_ptr
  {
  public:
    shared_ptr(T* ptr = nullptr)
      : _ptr(ptr)
      , _pCount(new int(1))
    {}
 
    void Release()
    {
      if (--(*_pCount) == 0) // 防止产生内存泄漏,和析构一样,写成一个函数
      {
        delete _ptr;
        delete _pCount;
      }
    }
    ~shared_ptr()
    {
      Release();
    }
 
    shared_ptr(const shared_ptr<T>& sp)
      : _ptr(sp._ptr)
      , _pCount(sp._pCount)
    {
      (*_pCount)++;
    }
 
    shared_ptr<T>& operator=(const shared_ptr<T>& sp)
    {
      //if (this != &sp)
      if (_ptr != sp._ptr) // 防止自己给自己赋值,注意不能比较this,类似s1 = s2; 再来一次s1 = s2;
      {                    // 比较_pCount也行
        //if (--(*_pCount) == 0) // 防止产生内存泄漏,和析构一样,写成一个函数
        //{
        //  delete _ptr;
        //  delete _pCount;
        //}
        Release();
 
        _ptr = sp._ptr;
        _pCount = sp._pCount;
        (*_pCount)++;
      }
      return *this;
    }
 
    T& operator*()
    {
      return *_ptr;
    }
    T* operator->()
    {
      return _ptr;
    }
  protected:
    T* _ptr;
    int* _pCount;// 引用计数,有多线程安全问题,学了linux再讲,不能用静态成员
  };

赋值重载需要注意细节的都在注释写了，可以自己画一个图看看。

5.2 循环引用

       shared_ptr 完美了吗？并不是，它有一个死穴：循环引用。创建一个链表节点，在该节点的析构函数中打印提示信息：

struct Node
{
  ~Node()
  {
    cout << "~Node" << endl;
  }
 
  int _val;
  std::shared_ptr<Node> _next;
  std::shared_ptr<Node> _prev;
};

将n1和n2互相指向，形成循环引用：

（因为要给_next和_prev赋值，所以Node里也要用智能指针）

int main()
{
  std::shared_ptr<Node> n1(new Node);
  std::shared_ptr<Node> n2(new Node);
 
  n1->_next = n2;
  n2->_prev = n1;
 
  return 0;
}

执行该程序后，节点析构函数中的打印信息并没有打印，说明析构出了问题。

如果不形成循环引用就会打印提示信息：

可以调用shared_ptr里的use_count接口打印引用计数值：

       n1和n2刚创建的时候，它两的引用计数值都是1。当两个节点循环引用后，它们的引用计数值都变成了2。

n2先析构，右边的引用计数变为1，n1再析构，左边的引用计数变为1，然后就没了。

左边结点的_next什么时候释放？-> 取决于左边的结点什么时候delete。

左边的结点什么时候delete？-> 取决于右边结点的_prev。

右边结点的_prev什么时候释放？-> 取决于右边的结点什么时候delete。

右边的结点什么时候delete？-> 取决于左边结点的_next。

左边结点的_next什么时候释放？ -> 回到一开始的问题，进入死循环。

在循环引用中，节点得不到真正的释放，就会造成内存泄漏。

循环引用的根本原因在于，next和prev也参与了资源的管理。

       这个漏洞shared_ptr本身也解决不了，所以就增加了weak_ptr来解决这个问题。解决办法就是让节点中的_next和_prev仅指向对方，而不参与资源管理，也就是计数值不增加。

这里为了配合上面和给下面模拟weak_ptr演示给我们的shared_ptr加两个接口函数：

从C语言到C++_36(智能指针RAII)auto_ptr+unique_ptr+shared_ptr+weak_ptr（下）：https://developer.aliyun.com/article/1522498?spm=a2c6h.13148508.setting.23.50c04f0ef94tTt