目录
- 一、理解智能指针
- 1.普通指针的使用
- 二、智能指针
- 1.auto_ptr
- 2.unique_ptr
- 3.shared_ptr
- （1）了解shared_ptr
- （2）shared_ptr的缺陷
- 4.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的循环引用被解决了。
