【C++】智能指针

目录
一、为什么需要智能指针
二、什么是内存泄漏
三、智能指针
3.1 原理
3.2 auto_ptr
3.3 unique_ptr
3.4 shared_ptr
3.5 weak_ptr
3.6 boost C++库与智能指针

---

一、为什么需要智能指针

在前面讲C++非常的时间提到过，在代码中抛出非常可能会导致实行流不测跳出函数，而函数中动态分配的空间没有被开释，造成内存泄漏
例如：

1. int div()
2. {
3.         int a = 1;
4.         int b = 0;
5.         if (b == 0)
6.                 throw "Division by zero condition!"; //除零错误
7.         else
8.                 return a / b;
9. }
11. void Func()
12. {
13.         int* p1 = new int;
14.         int* p2 = new int;
16.         div(); //抛出异常
18.         cout << "开始释放动态分配的空间" << endl;
19.         delete p1;
20.         delete p2;
21. }
23. int main()
24. {
25.         try {
26.                 Func();
27.         }
28.         catch (const char* errmsg)
29.         {
30.                 cout << "捕获异常：" << errmsg << endl;
31.         }
32.         catch (...)
33.         {
34.                 cout << "捕获未知异常" << endl;
35.         }
36.         return 0;
37. }

复制代码

在Func函数中有两个指针指向了动态分配的空间，在函数竣事的时间我们也必须要开释它们，否则会造成内存泄漏。但是中心调用div函数的时间会抛出非常，那还能否正常的开释这些空间呢？

可以看到，抛出非常后实行流就直接跳出Func函数，到了main函数中捕获非常的位置了。Func中申请的空间也没有被开释，造成内存泄漏

---

二、什么是内存泄漏

像上面如许，在程序中通过malloc/calloc/realloc/new等内存管理函数动态分配的堆内存空间，使用完后没有被free/delete开释，就会造成堆内存泄漏（Heap leak）。
因为疏忽或错误设计导致程序未能开释已经不再使用的内存的情况就叫做内存泄漏。内存泄漏并不是指内存完全消散，而是程序失去了对这些内存的控制。如果一次性泄漏许多内存，我们可能很快就会发现，但有时内存泄漏常常是聚沙成塔的，程序运行着越来越慢，末了导致卡死。
除了堆内存泄漏，程序使用系统分配的资源，如套接字、文件描述符、管道等，使用完后没有通过对应的函数开释，会导致系统资源的浪费，这属于系统资源泄漏。
要制止内存泄漏，一方面我们要养成良好的编码规范，申请的资源记得开释。但是如果碰上了例如上面这种抛出非常的场景，即使再怎么警惕也没有办法解决。
因此，对于这些资源，我们一样平常接纳RAII头脑来管理

---

三、智能指针

3.1 原理

智能指针是RAII头脑的一种实现方式，何为RAII？
RAII（Resource Acquisition Is Initialization，资源获取即初始化），通过将我们获取到的资源的生命周期与某个对象的生命周期绑定在一起，使用这个对象的生命周期来控制程序资源。
通过这种方式，我们只需要在对象的构造函数中获取资源，在析构函数中开释资源，使用类对象出作用域会自动析构的特点来自动开释资源，就完成了资源管理的托管。
这种方式有两大好处：

• 不需要显式的开释资源
  
• 对象管理的资源在其生命周期内始终有用，一旦超出生命周期，资源被自动开释，制止了因抛出非常等缘故起因导致资源没有开释造成内存泄漏
  

根据RAII头脑，我们可以设计出一个管理指针的一个类，只需要在这个类构造函数中获取指针，并在析构函数中将指针指向的空间开释，就能完成对动态分配的空间的管理，这就是智能指针
既然是智能指针，我们要让其可以或许像指针一样被使用，所以还需要在类内部重载解引用操作符(*)和箭头操作符(->)
现在，我们就可以设计一个最简单的智能指针了：

1. template<class T>
2. class SmartPtr
3. {
4. public:
5.         SmartPtr(T* ptr = nullptr)
6.                 :_ptr(ptr)
7.         {}
9.         T& operator*() { return *_ptr; }
11.         T* operator->() { return _ptr; }
13.         ~SmartPtr()
14.         {
15.                 cout << "~SmartPtr()" << endl;
16.                 if (_ptr)
17.                         delete _ptr;
18.         }
19. private:
20.         T* _ptr;
21. };

复制代码

把上面的指针换成智能指针，看看效果怎样：

可以看到，智能指针也可以或许像普通指针一样使用，而且在抛出非常后也会调用本身的析构函数，将资源开释，制止了内存泄漏
总结下来，智能指针的原理其实就两个：

• RAII头脑
  
• 重载操作符，可以或许像指针一样使用
  

上面我们实现的只是最简单的智能指针，具有智能指针的底子行为，在实际中还需要考虑更多的标题，例如指针的赋值等。为相识决这些标题，在C++的发展史中也曾诞生多个版本的智能指针

3.2 auto_ptr

上面我们实现的智能指针，虽然已经可以或许实现自动开释资源了，但是另有一些标题没有被解决
例如，假设我们将一个智能指针赋值给另外一个智能指针：

1. void Func()
2. {
3.         SmartPtr<int> p1(new int);
4.         SmartPtr<int> p2 = p1;
5. }
7. int main()
8. {
9.         Func();
10.         return 0;
11. }

复制代码

会发生什么呢？
此时，两个智能指针指向了同一块空间，析构时这块空间被开释了两次，导致发生错误
C++98的auto_ptr，针对这种标题给出相识决方案，即拷贝时将等号右侧的智能指针置为空

1. int main()
2. {
3.         auto_ptr<int> p1(new int);
4.         auto_ptr<int> p2 = p1;
5.         return 0;
6. }

复制代码

乍一听好像公道，解决了空间被重复开释的标题，但是指针管理权转移导致智能指针被置空的情况，碰到不熟悉机制的人就轻易导致发生空指针错误，例如：

而且，auto_ptr不支持对数组的内存管理

所以，auto_ptr其实是一个失败的设计，被许多人所诟病
要模仿实现auto_ptr也很简单，只需要在拷贝构造和赋值运算符重载函数中进行指针的管理权转移即可

1. namespace Eristic
2. {
3.         template<class T>
4.         class auto_ptr
5.         {
6.         public:
7.                 auto_ptr(T* ptr)
8.                         :_ptr(ptr)
9.                 {}
11.                 auto_ptr(auto_ptr<T>& ap)
12.                         :_ptr(ap._ptr)
13.                 {
14.                         ap._ptr = nullptr; //置空
15.                 }
17.                 auto_ptr<T>& operator=(auto_ptr<T>& ap)
18.                 {
19.                         if (this != &ap) //避免自己给自己赋值的情况
20.                         {
21.                                 if (_ptr)
22.                                         delete _ptr; //释放原有空间
23.                                 _ptr = ap._ptr;
24.                                 ap._ptr = nullptr;
25.                         }
26.                         return *this;
27.                 }
29.                 T& operator*()
30.                 {
31.                         return *_ptr;
32.                 }
34.                 T* operator->()
35.                 {
36.                         return _ptr;
37.                 }
39.                 ~auto_ptr()
40.                 {
41.                         if (_ptr)
42.                                 delete _ptr;
43.                 }
45.         private:
46.                 T* _ptr;
47.         };
48. }

复制代码

智能指针有三个常用的类方法，在这里用auto_ptr演示一下

• get()：返回智能指针内部存放的指针
  

• release()：返回指针，并取消智能指针对内存的管理
  

使用这个函数后，智能指针就不再对本身内部的指针进行管理，申请的资源需要我们手动开释

1. int main()
2. {
3.         auto_ptr<int> ap(new int);
4.         int* p1 = ap.release();
5.         delete p1;
6.         return 0;
7. }

复制代码

• reset()：修改智能指针内部托管的指针指向，如果指针的指向改变，析构原来的内存
  

3.3 unique_ptr

C++11之后，出现了unique_ptr，其特点在于直接禁止了智能指针的拷贝与赋值

如许，就不会导致智能指针因管理权转移而被置空，造成可能存在的空指针错误 
要实现这一点也很简单，将拷贝构造和赋值重载只声明不实现，并限定为私有，如许就可以制止有人在类外重新实现或调用这两个函数了。或者直接用delete修饰拷贝构造和赋值重载，也可以起到相同效果。
如果只是简单的禁止智能指针的拷贝与赋值，那么其功能要模仿实现也非常简单：

1. namespace Eristic
2. {
3.         template<class T>
4.         class unique_ptr
5.         {
6.         public:
7.                 unique_ptr(T* ptr)
8.                         :_ptr(ptr)
9.                 {}
11.                 ~unique_ptr()
12.                 {
13.                         if (_ptr)
14.                                 delete _ptr;
15.                 }
16.        
17.                 T& operator*()
18.                 {
19.                         return *_ptr;
20.                 }
22.                 T* operator->()
23.                 {
24.                         return _ptr;
25.                 }
27.                 unique_ptr(const unique_ptr<T>& sp) = delete;
28.                 unique_ptr<T>& operator=(const unique_ptr<T>& sp) = delete;
29.         private:
30.                 T* _ptr;
31.         };
32. }

复制代码

不过，虽然unique_ptr不能进行左值拷贝赋值操作，但允许move右值拷贝和赋值，例如：

而且，unique_ptr还支持对数组的内存管理

既然unique_ptr可以或许管理数组的内存空间，那么其内部必须要针对差别情况选择调用delete和delete[]，这又是怎样做到的呢？
其实是因为unique_ptr需要支持自定义删除器，即我们可以传入一个函数对象，用于智能指针对空间的开释。例如有时间智能指针指向的资源可能不是new出来的，也可能是malloc出来的，这时我们就无法用delete来开释资源了，需要本身定义一个函数对象来开释
不仅unique_ptr，背面的shared_ptr也支持自定义删除器，不过二者有一些差别之处，我们从二者的定义中也能看出来

可以看到，unique_ptr的第二个模板参数是一个缺省参数，在我们使用unique_ptr并传入自定义删除器时需要对该参数进行说明

1. template<class T>
2. struct DelArray
3. {
4.         void operator()(T* ptr)
5.         {
6.                 delete[] ptr;
7.         }
8. };
10. int main()
11. {
12.         unique_ptr<int, DelArray<int>> p1(new int[5], DelArray<int>());
13.         return 0;
14. }

复制代码

自定义删除器可以是普通函数，可以是仿函数，也可以是lambda表达式，由用户本身决定

3.4 shared_ptr

我们的原生指针是允许多个指针指向同一块空间的，而显然上面的auto_ptr和unique_ptr并没有符合指针的这一性质，因此C++11又提供了一种智能指针：shared_ptr
shared_ptr通过引用计数的方式来实现多个shared_ptr之间共同管理同一块空间，即shared_ptr赋值或拷贝一次，引用计数加一。直到引用计数为0，管理的空间才会被开释
通过use_count()方法我们可以获取shared_ptr的引用计数，例如：

多个shared_ptr对象指向同一份资源，当其中一个对象被烧毁，则引用计数减一，如果烧毁后引用计数变为0，则说明该对象是末了一个管理这份资源的对象，需要负责资源的开释；如果不为0，则说明另有别的对象在管理这份资源，不能开释，否则可能造成野指针错误
shared_ptr除了可以用构造函数初始化，也可以用make_shared

要实现shared_ptr的底子版本也很简单，将引用计数引入智能指针即可

1. namespace Eristic
2. {
3.         template<class T>
4.         class shared_ptr
5.         {
6.         public:
7.                 shared_ptr(T* ptr = nullptr)
8.                         :_ptr(ptr)
9.                         ,_pcount(new int(1))
10.                 {}
12.                 shared_ptr(const shared_ptr<T>& sp)
13.                         :_ptr(sp._ptr)
14.                         ,_pcount(sp._pcount)
15.                 {
16.                         ++(*_pcount); //增加引用计数
17.                 }
19.                 shared_ptr<T>& operator=(shared_ptr<T>& sp)
20.                 {
21.                         if (_ptr != sp._ptr)
22.                         {
23.                                 release(); //shared_ptr改变指向前需要对原来的引用计数减1
24.                                 _ptr = sp._ptr;
25.                                 _pcount = sp._pcount;
26.                                 ++(*_pcount); //增加引用计数
27.                         }
28.                         return *this;
29.                 }
31.                 T& operator*() { return *_ptr; }
33.                 T* operator->() { return _ptr; }
35.                 void release()
36.                 {
37.                         --(*_pcount); //对象被析构，引用计数减1
38.                         if (*_pcount == 0) //引用计数为0时才释放空间
39.                         {
40.                                 delete _ptr;
41.                                 delete _pcount;
42.                         }
43.                 }
45.         int use_count()
46.                 {
47.                         return *_pcount;
48.                 }
50.                 ~shared_ptr()
51.                 {
52.                         release();
53.                 }
54.         private:
55.                 T* _ptr;
56.                 int* _pcount; //引用计数
57.         };
58. }

复制代码

但是，shared_ptr也有一个缺点，当碰到两个shared_ptr互相指向对方时，可能导致循环引用标题
例如双向链表，节点中存在指针next和prev

1. struct ListNode
2. {
3.         int _val;
4.         Eristic::shared_ptr<ListNode> prev;
5.         Eristic::shared_ptr<ListNode> next;
7.         ~ListNode()
8.         {
9.                 cout << "~ListNode()" << endl;
10.         }
11. };

复制代码

此时让两个节点互相指向，就会导致循环引用，造成内存泄漏

可以看到并没有打印任何东西，说明ListNode的析构函数没有被调用，造成内存泄漏
循环引用是什么？为什么会导致shared_ptr无法开释本身管理的空间？我们用一张图表明

循环引用会导致两个互相指向的shared_ptr在各自析构后，引用计数仍不为0，所以不会开释资源

可以看到，二者的引用计数都是2 
要解决这个标题，还需要使用另一种智能指针：weak_ptr

3.5 weak_ptr

weak_ptr设计的目的是为了共同shared_ptr解决循环引用标题，一个weak_ptr对象只能由另一个shared_ptr或weak_ptr构造而来，且不会造成引用计数的增加或淘汰

可以看到，将ListNode中的shared_ptr换成weak_ptr，就可以或许正常开释资源了，因为其不会造成引用计数的变化，所以制止了上面的情况
需要注意的是，shared_ptr没有重载解引用操作符和箭头操作符，所以不支持像指针一样使用。但是我们可以通过调用其lock()方法生成一个新的shared_ptr

weak_ptr不支持RAII，它不是一个传统的智能指针
weak_ptr也会使用shared_ptr的引用计数，我们也可以通过调用use_count()来获取其引用计数
另外，我们还可以使用expired函数检测其指向的shared_ptr是否被开释，未开释返回false，已开释返回true

3.6 boost C++库与智能指针

C++中的boost库相当于C++尺度库的体验服，由boost社区负责开辟和发布，开辟人员遍布环球，负责开辟和收集高质量的库，作为C++尺度的补充。boost库中被证实有价值且实用的库则有机会在未来被纳入到C++尺度中
scoped_ptr（即现在的unique_ptr）、shared_ptr和weak_ptr都是在boost库中颠末了大众的检验，才敢正式使用，以制止当初auto_ptr的糟糕设计
完.

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。