智能指针

1. 概述

在实际的C++开发中，我们经常会遇到诸如程序运行中突然崩溃、程序运行所用内存越来越多最终不得不重启等问题，这些问题往往都是内存资源管理不当造成的。比如：

• 有些内存资源已经被释放，但指向它的指针并没有改变指向（成为了野指针），并且后续还在使用；
• 有些内存资源已经被释放，后期又试图再释放一次（重复释放同一块内存会导致程序运行崩溃）；
• 没有及时释放不再使用的内存资源，造成内存泄漏，程序占用的内存资源越来越多。

C++98/03标准中，支持使用auto_ptr智能指针来实现堆内存的自动回收；C++11新标准在废弃auto_ptr的同时，增添了unique_ptr、shared_ptr以及weak_ptr这3个智能指针来实现堆内存的自动回收。

C++智能指针底层是采用引用计数的方式实现的。简单理解，智能指针在申请堆内存空间的同时，会为其配备一个整型值（初始值为1），每当有新对象使用此堆内存时，该整形值加1；反之，每当使用此堆内存的对象被释放时，该整型值减1。当堆空间对应的整型值为0时，即表明不再有对象使用它，该堆空间就会被释放掉。

下面介绍三种智能指针，注意：每种智能指针都是以类模板的方式实现的，定义位于<memory>头文件，并位于std命名空>间中，因此在使用该类型指针时，程序中应包含如下2行代码：

#include <memory>
using namespace std;

2. shared_ptr

和unique_ptr、weak_ptr不同之处在于，多个shared_ptr智能指针可以共同使用同一块堆内存。并且，由于该类型智能指针在实现上采用的是引用计数机制，即便有一个shared_ptr`指针放弃了堆内存的“使用权”（引用计数减1），也不会影响其他指向同一堆内存的shared_ptr指针（只有引用计数为 0 时，堆内存才会被自动释放）。

2.1. 创建

介绍一下几种创建方式：

（1）创建空智能指针

std::shared_ptr<int> p1;             // 不传入任何实参
std::shared_ptr<int> p2(nullptr);    // 传入空指针nullptr

注意，空的shared_ptr指针，其初始引用计数为0，而不是1。

（2）创建非空shared_ptr智能指针，明确其指向。

std::shared_ptr<int> p3(new int(10));

这样就成功构建了一个shared_ptr智能指针，其指向一块存有10个int类型数据的堆内存空间。

同时，C++11标准中还提供了std::make_shared<T>模板函数，其可以用于初始化shared_ptr智能指针，例如：

std::shared_ptr<int> p3 = std::make_shared<int>(10);

以上2种方式创建的p3是完全相同。

（3）拷贝构造和移动构造

//调用拷贝构造函数
std::shared_ptr<int> p4(p3);
std::shared_ptr<int> p4 = p3;
//调用移动构造函数
std::shared_ptr<int> p5(std::move(p4));
std::shared_ptr<int> p5 = std::move(p4);

如上所示，p3和p4都是shared_ptr类型的智能指针，因此可以用p3来初始化p4，由于p3是左值，因此会调用拷贝构造函数。需要注意的是，如果p3为空智能指针，则p4也为空智能指针，其引用计数初始值为0；反之，则表明p4和p3指向同一块堆内存，同时该堆空间的引用计数会加1。

而对于std::move(p4)来说，该函数会强制将p4转换成对应的右值，因此初始化p5调用的是移动构造函数。另外和调用拷贝构造函数不同，用std::move(p4)初始化p5，会使得p5拥有了p4的堆内存，而p4则变成了空智能指针。

注意，同一普通指针不能同时为多个shared_ptr对象赋值，否则会导致程序发生异常。例如：

int* ptr = new int;
std::shared_ptr<int> p1(ptr);
std::shared_ptr<int> p2(ptr);//错误

2.2. 释放

再介绍一下shared_ptr的自定义释放规则，在初始化时可以自定义所指堆内存的释放规则，这样当堆内存的引用计数为0时，会优先调用自定义的释放规则。在某些场景中，自定义释放规则是很有必要的。比如，对于申请的动态数组来说，shared_ptr指针默认的释放规则是不支持释放数组的，只能自定义对应的释放规则，才能正确地释放申请的堆内存。

对于申请的动态数组，释放规则可以使用C++11标准中提供的default_delete<T>模板类，也可以自定义释放规则：

//指定 default_delete 作为释放规则
std::shared_ptr<int> p6(new int[10], std::default_delete<int[]>());

//自定义释放规则
void deleteInt(int*p) {
    delete []p;
}

//初始化智能指针，并自定义释放规则
std::shared_ptr<int> p7(new int[10], deleteInt);

借助lambda表达式，还可以像如下这样初始化p7：

std::shared_ptr<int> p7(new int[10], [](int* p) { delete []p; });

2.3. 方法

总结一下shared_ptr的成员方法：

方法名	功能
operator=()	重载赋值号，使得同一类型的shared_ptr智能指针可以相互赋值。
operator*()	重载*号，获取当前shared_ptr智能指针对象指向的数据。
operator->()	重载->号，当智能指针指向的数据类型为自定义的结构体时，通过->运算符可以获取其内部的指定成员。
swap()	交换2个相同类型shared_ptr智能指针的内容。
reset()	当函数没有实参时，该函数会使当前shared_ptr所指堆内存的引用计数减1，同时将当前对象重置为一个空指针；当为函数传递一个新申请的堆内存时，则调用该函数的shared_ptr对象会获得该存储空间的所有权，并且引用计数的初始值为1。
get()	获得shared_ptr对象内部包含的普通指针。
use_count()	返回同当前shared_ptr对象（包括它）指向相同的所有shared_ptr对象的数量。
unique()	判断当前shared_ptr对象指向的堆内存，是否不再有其它shared_ptr对象再指向它。
operator bool()	判断当前shared_ptr对象是否为空智能指针，如果是空指针，返回false；反之，返回true。

3. unique_ptr

作为智能指针的一种，unique_ptr指针也具备“在适当时机自动释放堆内存空间”的能力。和shared_ptr指针最大的不同之处在于，unique_ptr指针指向的堆内存无法同其它unique_ptr共享，也就是说，每个unique_ptr指针都独自拥有对其所指堆内存空间的所有权。

这也就意味着，每个unique_ptr指针指向的堆内存空间的引用计数，都只能为1，一旦该unique_ptr指针放弃对所指堆内存空间的所有权，则该空间会被立即释放回收。

3.1. 创建

（1）创建空unique_ptr指针

std::unique_ptr<int> p1();
std::unique_ptr<int> p2(nullptr);

（2）创建非空unique_ptr指针

std::unique_ptr<int> p3(new int);

（3）移动构造

std::unique_ptr<int> p4(new int);
std::unique_ptr<int> p5(p4);//错误，堆内存不共享
std::unique_ptr<int> p5(std::move(p4));//正确，调用移动构造函数

3.2. 释放

默认情况下，unique_ptr指针采用std::default_delete<T>方法释放堆内存。当然，我们也可以自定义符合实际场景的释放规则。值得一提的是，和shared_ptr指针不同，为unique_ptr自定义释放规则，只能采用函数对象的方式。例如：

//自定义的释放规则
struct myDel
{
    void operator()(int *p) {
        delete p;
    }
};
std::unique_ptr<int, myDel> p6(new int);
//std::unique_ptr<int, myDel> p6(new int, myDel());

3.3. 方法

总结一下unique_ptr的成员方法：

方法名	功能
operator=()	重载赋值号，从而可以将nullptr或者一个右值unique_ptr指针直接赋值给当前同类型的unique_ptr指针。
operator*()	重载*号，获取当前unique_ptr智能指针对象指向的数据。
operator->()	重载->号，当智能指针指向的数据类型为自定义的结构体时，通过->运算符可以获取其内部的指定成员。
operator[]()	重载[]号，当unique_ptr指针指向一个数组时，可以直接通过[]获取指定下标位置处的数据。
swap(x)	交换当前unique_ptr指针和同类型的x指针。
reset(p)	其中p表示一个普通指针，如果p为nullptr，则当前unique_ptr也变成空指针；反之，则该函数会释放当前unique_ptr指针指向的堆内存（如果有），然后获取p所指堆内存的所有权（p为nullptr）。
get()	获得unique_ptr对象内部包含的普通指针。
get_deleter()	获取当前unique_ptr指针释放堆内存空间所用的规则。
release()	释放当前unique_ptr指针对所指堆内存的所有权，但该存储空间并不会被销毁。
operator bool()	unique_ptr指针可直接作为if语句的判断条件，以判断该指针是否为空，如果为空，则为false；反之为true。

4. weak_ptr

C++11标准虽然将weak_ptr定位为智能指针的一种，但该类型指针通常不单独使用（没有实际用处），只能和shared_ptr类型指针搭配使用。甚至于，我们可以将weak_ptr类型指针视为shared_ptr指针的一种辅助工具，借助weak_ptr类型指针，我们可以获取shared_ptr指针的一些状态信息，比如有多少指向相同的shared_ptr指针、shared_ptr指针指向的堆内存是否已经被释放等等。

需要注意的是，当weak_ptr类型指针的指向和某一shared_ptr指针相同时，weak_ptr指针并不会使所指堆内存的引用计数加1；同样，当weak_ptr指针被释放时，之前所指堆内存的引用计数也不会因此而减1。也就是说，weak_ptr类型指针并不会影响所指堆内存空间的引用计数。

除此之外，weak_ptr<T>模板类中没有重载*和->运算符，这也就意味着，weak_ptr类型指针只能访问所指的堆内存，而无法修改它。

4.1. 创建

（1）创建空weak_ptr指针

std::weak_ptr<int> wp1;

（2）根据已有weak_ptr指针创建

std::weak_ptr<int> wp2 (wp1);

（3）根据已有shared_ptr指针创建

std::shared_ptr<int> sp (new int);
std::weak_ptr<int> wp3 (sp);

4.2. 方法

总结一下weak_ptr的成员方法：

方法名	功能
operator=()	重载赋值号，使得weak_ptr指针可以直接被weak_ptr或者shared_ptr类型指针赋值。
swap(x)	其中x表示一个同类型的weak_ptr类型指针，该函数可以互换2个同类型weak_ptr指针的内容。
reset()	将当前 weak_ptr 指针置为空指针。
use_count()	查看指向和当前weak_ptr指针相同的shared_ptr指针的数量。
expired()	判断当前weak_ptr指针为否过期（指针为空，或者指向的堆内存已经被释放）。
lock()	如果当前weak_ptr已经过期，则该函数会返回一个空的shared_ptr指针；反之，该函数返回一个和当前weak_ptr指向相同的shared_ptr指针。