C++ 智能指针的原理：auto_ptr、unique_ptr、shared_ptr、weak_ptr

本文代码在win10的vs2019中通过编译。

一、理解智能指针

1.普通指针的使用

  如果程序需要动态申请内存空间，我们通常使用malloc或者new从堆上申请空间，从堆上申请的空间是需要释放的，否则就会造成内存泄漏。

  不同的申请方式也对应着不同的释放方式，malloc申请的空间通过free释放，new申请的空间通过delete释放。

  正常来讲，如果我们从堆上申请了空间，那么在空间使用完毕后就需要将空间释放，但是如果程序在运行时出错，直接崩溃，那么我们的空间就来不及释放，从而造成资源泄露。

  下面这段代码因为试图对空指针解引用，因此会崩溃，所以ptr指向的空间就没有释放，造成资源泄露：

#define _CRT_SECURE_NO_WARNINGS
#include "iostream"
using namespace std;int main() {	int* ptr = new int;//ptr指针申请了空间int* pn = nullptr;//pn指针指向空cout << *pn;//对空指针解引用，造成崩溃delete ptr;//释放ptr申请的空间（因为程序崩溃，无法运行到这里）
}

  因此，如果要避免这种情况，就需要在所有可能会中途退出的位置之前释放资源，或者是使用异常来解决。但这样的解决办法会让代码变得复杂、庞大。

  因此我们需要一种智能的指针，让指针使用完毕后自动释放申请的空间，也就是智能指针。

  我们可以自己来实现一个简单的智能指针，当然会有很多缺陷，但主要是了解一下思想。想一想类的构造函数和析构函数，生成一个类的对象时，调用构造方法，销毁类的对象时，调用析构方法。因此我们可以在构造函数中传入空间地址，在析构函数中释放资源，这样就可以把一个类的对象当指针一样使用了。

  看看下面这段代码：

#define _CRT_SECURE_NO_WARNINGS
#include "iostream"
using namespace std;template<typename T>
class SmartPtr {
public:T* ptr;//指针
public:SmartPtr(T* _p = nullptr):ptr(_p){}~SmartPtr() {if (ptr != nullptr) {delete ptr;//释放空间}}T& operator*() {return *ptr;}T* operator->() {return ptr;}
};struct Num {int a;int b;
};void Test() {//new会从堆上申请空间并返回空间首地址，将空间首地址作为参数传递SmartPtr<int> s1(new int);*s1 = 10;//通过重载的*运算符修改空间中的值SmartPtr<Num> s2(new Num);s2->a = 11;//通过->运算符直接访问结构体对象的成员变量s2->b = 12;
}int main() {Test();_CrtDumpMemoryLeaks();//检测内存泄漏
}

  但是这个简单版本的智能指针有一个很大的缺点，浅拷贝。编译器生成的默认拷贝构造函数和赋值运算符重载都是浅拷贝，如果通过拷贝构造和赋值运算符重载来给其他对象赋值，当对象生命周期结束调用析构函数的时候，就会因为多次释放同一个资源造成程序崩溃。

  但是不能因为要解决浅拷贝的问腿，就自己定义深拷贝的拷贝构造函数和赋值运算符重载，因为智能指针是把对象当指针一样使用，指针只负责管理资源。如果我们进行深拷贝，那么多个对象就不能使用同一份资源了。

二、智能指针

  为了解决浅拷贝的问腿，来介绍C++中的智能指针，这里介绍四种：auto_ptr（不推荐使用，仅作了解）、unique_ptr（直接禁止拷贝）、shared_ptr、weak_ptr。

1.auto_ptr

  解决浅拷贝的方式：资源转移，如果要用b给a赋值（或者是拷贝构造），就直接把b的资源转移给a，然后让b指向空。（所以b就不能使用这个资源了）

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <memory>
using namespace std;void Test() {auto_ptr<int> ap1(new int);*ap1 = 10;auto_ptr<int> ap2(ap1);//用ap1拷贝构造ap2*ap2 = 12;
}int main() {Test();_CrtDumpMemoryLeaks();//检测内存泄漏
}

  来看看auto_ptr的缺陷：如图所示，用ap1拷贝构造ap2后，ap1的指针就置为空了（因为资源从ap1转移给ap2了，ap1以后就不能使用这个资源了）。因此不推荐使用，不然很可能在不知情的情况下就去对ap1解引用了。

2.unique_ptr

  解决浅拷贝的方式：禁止拷贝，只要不能拷贝，就不会有浅拷贝发生。（从根源解决问题）

  如果确定这个资源只会被一个指针管理，就使用unique_ptr。

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <memory>
using namespace std;void Test() {unique_ptr<int> up1(new int);*up1 = 10;//unique_ptr<int> up2(up1); 用up1拷贝构造up2会报错//unique_ptr<int> up3 = up1; 用up1给up2赋值会报错
}int main() {Test();_CrtDumpMemoryLeaks();//检测内存泄漏
}

3.shared_ptr

（1）了解shared_ptr

  解决浅拷贝的方式：引用计数。通过计数来判断当前有多少个shared_ptr指向了这个被管理的资源，当计数变成0，说明此时没有指针管理这个资源，因此可以释放这个资源。

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <memory>
using namespace std;void Test() {shared_ptr<int> sp1(new int);*sp1 = 10;shared_ptr<int> sp2(sp1);*sp2 = 11;*sp1 = 12;cout << "sp1管理的资源同时被 " << sp1.use_count() << " 个智能指针管理" << endl;
}int main() {Test();_CrtDumpMemoryLeaks();//检测内存泄漏
}

  如图所示：sp1和sp2同时管理资源，资源的地址是一样的，说明两个指针管理的是同一个资源。

  shared_ptr中有两个变量，一个变量（ptr）指向资源的空间首地址，另一个变量（pcount）指向引用计数的空间。引用计数空间的值初始状态是1，每当有一个智能指针管理了这个资源，就会将这个资源对应的引用计数加1，每当有一个智能指针不再管理这个资源，就会把引用计数减1，当引用计数变成0，说明已经没有指针管理这个资源，因此就可以释放这个资源了。

（2）shared_ptr的缺陷

  shared_ptr有一个很大的缺陷：循环引用。

  如下代码，定义了链表结点结构体 struct ListNode，该结构体包含了三个成员变量，value用来保存该结点的值，next用来指向下一个链表结点，prev用来指向前一个链表结点。next和prev都是shared_ptr类型的智能指针变量。

  在函数Testshared()中，使用智能指针shared_ptr管理ListNode对象，然后更新它们的指针指向，让两个链表结点连接起来。

  这份代码运行完毕以后会造成资源泄露。

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <memory>
using namespace std;struct ListNode {
public:shared_ptr<ListNode> next;//next指向下一个链表结点shared_ptr<ListNode> prev;//prev指向前一个链表结点int value;
public:ListNode(const int data=0) :next(nullptr),prev(nullptr),value(data){}~ListNode() {cout << "析构函数" << endl;}
};void Testshared() {shared_ptr<ListNode> sp1(new ListNode(4));shared_ptr<ListNode> sp2(new ListNode(5));sp1->next = sp2;sp2->prev = sp1;
}int main() {Testshared();_CrtDumpMemoryLeaks();//检测内存泄漏
}

  来看看为什么会造成资源泄露。

  下图是sp1和sp2刚构建好的样子，智能指针内部的ptr指针指向链表结点（资源）的首地址，pcount指针指向存储引用计数的空间。

  刚创建出来sp1和sp2时，由于每个链表结点都只被一个智能指针管理，因此引用计数都是1。

  下图是 sp1->next = sp2; sp2->prev = sp1; 执行后的情况，因为ListNode结构体内部的next和prev是用shared_ptr实现的，因此next和prev也具有指针ptr和引用计数pcount。

  由于ListNode2被ListNode1的next指向，也就代表着多了一个指针管理ListNode2，因此ListNode2的引用计数需要加1。

  ListNode1被ListNode2的prev指向，代表着多了一个指针管理ListNode1，因此ListNode1的引用计数需要加1。

  当Testshared函数执行完毕，作为局部对象的sp1和sp2就需要被销毁，后创建的先销毁，因此首先销毁sp2。

  sp2的ptr与ListNode2断开连接，然后会将引用计数空间的值减1，引用计数变成1，代表还有1个指针在管理ListNode2，因此不能释放ListNode2的资源。

  然后销毁sp1，sp1同样先断开与ListNode1的联系，然后将引用计数空间的值减1，引用计数变成1，代表还有1个指针在管理ListNode1，因此不能释放ListNode1的资源。

  然后现在就尴尬了，如果要释放ListNode1，就要先把ListNode1的引用计数置为0，因此需要让ListNode2的prev不要指向ListNode1，而ListNode2的prev是ListNode2的成员变量，因此就必须要释放ListNode2才能让prev断开与ListNode1的联系。

  但是要释放ListNode2就需要把ListNode2的引用计数置为0 ……

  这样就成套娃了，因此直到最后也没有释放资源，析构函数没有调用，造成了内存泄漏。

  如下图：

4.weak_ptr

  weak_ptr无法单独管理资源。

  weak_ptr就是用来解决shared_ptr的循环引用的，将weak_ptr和shared_ptr搭配使用，就可以解决循环引用的问题。

  在上面介绍shared_ptr的时候，为了方便理解，因此直接说的是引用计数。实际上shared_ptr的引用计数有两个：_Uses 和 _Weaks。（两个值初始值都是1）

  一个资源每当被一个shared_ptr智能指针管理，那么_Uses加1。一个资源每当被weak_ptr智能指针管理，_Weaks加1。

  因此_Uses 和 _Weaks就表示了这个资源被多少个weak_ptr智能指针或者多少个shared_ptr智能指针管理。

  当引用计数空间的 _Uses 变成0，说明被管理的资源可以释放了。当_Uses 和 _Weaks都变成0，说明引用计数空间可以被释放了。

  将前一段代码进行改造，将next和prev改为weak_ptr智能指针，同时要去掉构造函数中的相关内容。因为weak_ptr不能单独管理资源，就连空指针都不允许。

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <memory>
using namespace std;struct ListNode {
public:weak_ptr<ListNode> next;//next指向下一个链表结点weak_ptr<ListNode> prev;//prev指向前一个链表结点int value;
public:ListNode(const int data = 0): value(data){}~ListNode() {cout << "析构函数" << endl;}
};void Testshared() {shared_ptr<ListNode> sp1(new ListNode(4));shared_ptr<ListNode> sp2(new ListNode(5));sp1->next = sp2;sp2->prev = sp1;
}int main() {Testshared();_CrtDumpMemoryLeaks();//检测内存泄漏
}

  通过图片来理解改造后的代码，下图是刚创建出来sp1和sp2的情况。sp2和sp1指向的引用计数空间中有两个值：_Uses 和 _Weaks。（初始状态都是1）

  当 sp1->next = sp2; sp2->prev = sp1; 运行后，ListNode1的next指向了ListNode2，ListNode2的prev指向了ListNode1。

  ListNode1的next指向ListNode2，因此next中的_Ptr指向ListNode2的空间首地址，_Rep指向ListNode2的引用计数空间。另一方同理。

  因为next和prev是weak_ptr智能指针，因此两方的引用计数空间的_Weaks都要加1，_Weaks变成2。

  如图：

  当Testshared函数执行完毕，作为局部变量的sp1和sp2就要被销毁，后创建的先销毁，因此先销毁sp2。

  首先断开sp2的_Ptr和ListNode2的联系，因此该链表结点对应的引用计数空间的_Uses要减1，_Uses变成0，说明可以释放ListNode2了，因此需要把ListNode2的prev与ListNode1断开联系，因此ListNode1对应的引用计数空间的_Weaks需要减1，_Weaks变成1。

  把ListNode2的资源处理干净后，就需要把ListNode2对应的引用计数空间的_Weaks减1，然后sp2就可以释放了。ListNode2对应的引用计数空间的_Weaks变成1，说明该链表结点对应的引用计数空间还不能释放。

  释放了sp2后就需要释放sp1了，首先断开sp1的_Ptr和LsitNode1的联系，这样该链表结点对应的引用计数空间的_Uses就需要减1，_Uses变成0，说明ListNode1的资源可以释放了，这样就需要断开next和其他结点的联系，然后ListNode2对应的引用计数空间的_Weaks就需要减1，_Weaks变成0，说明引用计数空间可以释放了。

  ListNode1的资源处理后，ListNode1对应的引用计数空间中的_Weaks就需要减1，然后_Weaks变成0，说明这个引用计数空间可以被释放了。

  析构函数此时也被正常调用了，shared_ptr的循环引用被解决了。