C11新特性之智能指针

程序都是在堆上存储动态分配对象，而它的生存期是由程序来控制的。这就意味着当动态对象不再使用的时候，我们需要显式的将它销毁。

c98提出了一个智能指针auto_ptr为了避免人们使用指针时忘记释放内存。但是因为auto_ptr的总总缺点，使人们在开发过程碰到了各种坑，所以才有了c11新的三个智能指针。

在思考auto_ptr不适用之前我们先思考一下上面叫移动语义？

移动语义是c11提出的，c11最大的特性就是拥有了移动而不是拷贝对象的能力，这就大幅度的提升了性能。
为了让自定义类型的对象也支持移动操作，我们为它定义了移动构造函数和移动赋值运算符。
移动构造函数是对资源进行窃取而不是拷贝。它的第一个参数是该类类型的右值引用，移动构造函数除了完成资源移动外，还必须保证移动之后的原对象处于有效的、可析构的状态（将原对象值赋值给新对象，然后把原对象属性值置空，特别是指针成员置空！那么此时原对象就是处于可析构的安全状态）。

拷贝构造与移动构造

// 拷贝赋值运算符 
  MemoryBlock& operator=(const MemoryBlock& other) 
  { 
    if (this != &other) 
    { 
      delete[] _data; 
      _length = other._length; 
      _data = new int[_length]; 
      std::copy(other._data, other._data + _length, _data); 
    } 
    return *this; 
  } 
 
  // 拷贝构造函数 
  MemoryBlock(const MemoryBlock& other) 
    : _length(0) 
    , _data(nullptr) 
  { 
    *this = other; 
  } 
 // 移动赋值运算符，通知标准库该构造函数不抛出任何异常
  MemoryBlock& operator=(MemoryBlock&& other) noexcept
  {
    if (this != &other) 
    {  
      delete[] _data; 
      // 移动资源
      _data = other._data; 
      _length = other._length; 
      // 使移后源对象处于可销毁状态
      other._data = nullptr; 
      other._length = 0; 
    } 
    return *this; 
  }
 
  // 移动构造函数
  MemoryBlock(MemoryBlock&& other) noexcept
    _data(nullptr) 
    , _length(0) 
  { 
    *this = std::move(other); 
  } 

为什么不适用auto_ptr？

• 缺陷1：auto_ptr缺乏移动语义，它只是单纯的在赋值或构造函数中转移传入的原指针的所有权，并将原指针置空。

    auto_ptr<A> pa(new A(123));  
    pa->print();   
    //delete pa;  
    /*智能指针的问题,普通指针肯定没问题*/  
    auto_ptr<A> pb = pa;//拷贝构造  
    pb->print();  
    /*段错误*/  //因为此时pa已经被置空了
    pa->print(); 

• 缺陷2：auto_ptr不能管理对象数组。
  对象数组的分配比较不一样，除了分配需要的存储空间之外，堆内存的开头还会分配4个字节的空间来存放对象的个数。
  delete[]在原有的数组地址上减去4个字节，取得了真正的初始地址，这样才能正确释放数组。而delete只是用于释放单个对象，不能正确释放数组。我们的auto_ptr的析构函数中使用的是delete

//下面是auto_ptr源码中的析构函数
~auto_ptr() _NOEXCEPT
{   
    // destroy the object
    delete _Myptr;  
}

好了，逼逼完前面的一大堆，现在重头戏来了

看了memory里的部分源码，发现有一个在c11之前没有出现过的关键字explict

什么是explict关键字？

有了explict关键字的限定，防止类构造函数进行隐式转换

shared_ptr<int> p1 = new int(1024);  
//这种是不行的，因为等号右边是一个int*的指针。
//因为有explict修饰，所以它不能被隐式的转换为shared_ptr<int>的类型
shared_ptr<int> p2(new int(1024));   
//这种是直接采用了初始化的形式

• shared_ptr：运行多个指针指向同一对象，是强引用
• unique_ptr：独占指针对象，保证指针所指对象的生命周期与其一致
• weak_ptr：它不能决定对象的生命周期，引用所指对象时，需要lock()成shared_ptr才能使用

unique_ptr

它禁止拷贝语义，但是是通过移动语义（什么是移动语义？上面有解答）来实现的。它“唯一”拥有它所指的对象。
从下面的unique_ptr的构造函数就可以发现它是禁止拷贝语义的。

unique_ptr(const _Myt&) = delete;
_Myt& operator=(const _Myt&) = delete;

但是如果想要切换指针的控制权，可以使用下面的移动构造函数来进行控制权的转化，这里用到forward转发（上一节可以知道forward转发可以返回该参数本来对应的类型的引用），其实这里就是把右值对象移动给左值，并且把右值对象置空

unique_ptr(unique_ptr&& _Right) _NOEXCEPT
: _Mybase(_Right.release(),_STD forward<_Dx>(_Right.get_deleter()))
{   // construct by moving _Right
}

shared_ptr

了解了前面的auto_ptr和unique_ptr，再来理解shared_ptr非常容易。
与前面两者不同的是，shared_ptr允许多个指针指向相同对象，前两者在切换控制权时，会将前面的清除，而shared_ptr不会。

shared_ptr<Base1> base1(new Base1);  
shared_ptr<Base1> base2=base1;  
shared_ptr<Base1> base3;  
base3 = base2;//三个共享一个

当删除其中一个智能指针时，另外两个并不会受到变化。因为此时内存中存在着引用计数，每添加一个shared_ptr，引用计数+1，每次调用析构函数，引用计数-1。直到引用计数减为0，才会释放该块内存。
auto_ptr和unique_ptr都可以通过move函数转换成shared_ptr类型
当使用shared_ptr时，最需要注意的就是避免循环引用，它会造成堆内存无法正常释放，出现内存泄露。如何解决这个问题呢，这时候就要用到weak_ptr的lock()锁

weak_ptr

• weak_ptr是为了配合shared_ptr而引入的，它不存在重载operate*和->。
• 它最大的作用就是协助shared_ptr，像旁观者一样查看资源的使用情况。
• 它可以从一个shared_ptr或另一个weak_ptr对象中构造，获取资源的查看权。
• 它不存在共享资源，所以不会对内存块中的引用计数造成影响。即使weak_ptr也指向同一个内存，但是此时最后一个shared_ptr被销毁，那么对象就会被释放。

shared_ptr<string> s1(new string);
shared_ptr<string> s2 = s1;
weak_ptr<string> w1 = s2;

s1,s2为shared_ptr，w1为weak_ptr 调用s1.reset()
s2.reset()

我们最好在使用weak_ptr访问对象时，使用lock()函数，它可以检测weak_ptr访问的对象是否存在，如果存在，返回一个内存中的shared_ptr对象，不存在，返回一个nullptr的shared_ptr

为什么使用shared_pre会发生循环引用？

当双向链表的前驱指针和后继指针使用了shared_pre，如下

双向链表

由于使用了shared_pre，一块内存空间有两个对象进行管理，而无法使引用计数为0，那么编译器就无法自动释放内存。

如何解决shared_pre的循环引用？

使用弱引用，弱引用并不会修改对象的引用计数，也就是弱引用并不会对对象的内存进行管理。但是它能检测到引用对象是否被释放，避免了内存泄露。weak_pre就是弱引用。

  
struct Node  
{  
    weak_ptr<Node> _pre;  
    weak_ptr<Node> _next;  
  
    ~Node()  
    {  
        cout << "~Node():" << this << endl;  
    }  
    int data;  
};  
  
void FunTest()  
{  
    shared_ptr<Node> Node1(new Node);  
    shared_ptr<Node> Node2(new Node);  
    Node1->_next = Node2;  
    Node2->_pre = Node1;  
  
    cout <<"Node1.use_count:"<< Node1.use_count() << endl;  
    cout <<"Node2.use_count:"<< Node2.use_count() << endl;  
}  
  
int main()  
{  
    FunTest();  
    system("pause");  
    return 0;  
}
//此时输出的use_count分别为1,1