C++—智能指针

C++——智能指针

1.为什么必要智能指针

其实和异常有关系，看下面这段代码就明确了：

1. // 首先为什么需要智能指针呢？
2. // 前面我们学过异常，在异常中有一个异常安全的问题，就是异常会打乱执行流导致内存泄漏和死锁之类的问题
3. // 虽然c++本身有一个解决方案——先捕获处理在重新抛出异常
4. // 但是这种方案不太好，为什么？看下面这段代码：
6. int div()
7. {
8.         int a, b;
9.         cin >> a >> b;
10.         if (b == 0)
11.                 throw invalid_argument("除0错误");
12.         return a / b;
13. }
14. void Func()
15. {
16.         // 1、如果p1这里new 抛异常会如何？
17.         // 2、如果p2这里new 抛异常会如何？
18.         // 3、如果div调用这里又会抛异常会如何？——这里采用捕获再重新抛异常
19.         int* p1 = new int;
20.         int* p2 = new int;
21.         try
22.         {
23.                 cout << div() << endl;
24.         }
25.         catch (exception& e)
26.         {
27.                 delete p1;
28.                 delete p2;
29.                 throw e;
30.         }
31.         // 这种情况我们会发现，p1和p2如果new的时候抛异常会很不好处理。因此为了解决这个问题，智能指针就出来了
33.         delete p1;
34.         delete p2;
35. }
38. int main()
39. {
40.         try
41.         {
42.                 Func();
43.         }
44.         catch (exception& e)
45.         {
46.                 cout << e.what() << endl;
47.         }
49.         return 0;
50. }

复制代码

上面这段代码会导致内存泄漏，这是由于抛异常打乱实行流导致该开释的资源没有正常被开释所导致的，除了内存泄漏，抛异常还可以导致死锁的标题。
这里在复习一下内存泄漏：
   

• **什么是内存泄漏：**内存泄漏指由于疏忽或错误造成程序未能开释已经不再使用的内存的环境。内存泄漏并不是指内存在物理上的消失，而是应用程序分配某段内存后，由于计划错误，失去了对该段内存的控制，因而造成了内存的浪费。
  
• **内存泄漏的危害：**长期运行的程序出现内存泄漏，影响很大，如操纵系统、后台服务等等，出现内存泄漏会导致相应越来越慢，终极卡死。
  
• 内存泄漏的两种方面
  C/C++程序中一样平常我们关心两种方面的内存泄漏：
  
  
  
  • 堆内存泄漏(Heap leak)
    堆内存指的是程序实行中依据须要分配通过malloc / calloc / realloc / new等从堆中分配的一块内存，用完后必须通过调用相应的 free大概delete 删掉。假设程序的计划错误导致这部分内存没有被开释，那么以后这部分空间将无法再被使用，就会产生Heap Leak。
    
  • 系统资源泄漏
    指程序使用系统分配的资源，比方套接字、文件描述符、管道等没有使用对应的函数开释掉，导致系统资源的浪费，严重可导致系统效能减少，系统实行不稳定。
    
  
  
• 如何避免内存泄漏：
  
  
  
  • 工程前期精良的计划规范，养成精良的编码规范，申请的内存空间记着匹配的去开释。ps：这个理想状态。但是如果碰上异常时，就算注意开释了，还是可能会出标题。必要下一条智能指针来管理才有保证。
    
  • 采用RAII思想大概智能指针来管理资源
    
  • 有些公司内部规范使用内部实现的私有内存管理库。这套库自带内存泄漏检测的功能选项。
    
  • 出标题了使用内存泄漏工具检测。ps：不外很多工具都不够靠谱，大概收费昂贵。
    
  
  

  2.智能指针的使用和原理

那智能指针是如何解决这里的标题标呢？下面给一个例子：
SmartPtr.h：

1. #pragma once
2. #include<iostream>
3. using namespace std;
5. template<class T>
6. class SmartPtr
7. {
8. public:
9.         SmartPtr(T* ptr)
10.                 :_ptr(ptr)
11.         {}
13.         ~SmartPtr()
14.         {
15.                 if (_ptr)
16.                 {
17.                         cout << "delete: " << _ptr << endl;
18.                         delete _ptr;
19.                 }
20.         }
22. private:
23.         T* _ptr;
24. };

复制代码

test.cpp:

1. // 下面我们来看看智能指针是如何解决这个问题的
2. #include"SmartPtr.h"
3. int div()
4. {
5.         int a, b;
6.         cin >> a >> b;
7.         if (b == 0)
8.                 throw invalid_argument("除0错误");
10.         return a / b;
11. }
13. void Func()
14. {
15.         // 用智能指针来解决内存泄漏的问题
16.         int* p1 = new int();
17.         cout << p1 << endl;
18.         SmartPtr<int> sp1(p1); //有了智能指针哪怕在div中抛异常了，也能释放掉p1的资源
19.         cout << div() << endl;
20. }
22. int main()
23. {
24.         try
25.         {
26.                 Func();
27.         }
28.         catch (exception& e)
29.         {
30.                 cout << e.what() << endl;
31.         }
33.         return 0;
34. }

复制代码

实行结果如下：

可以发现，出现了抛异常后，我们没有做捕获在抛出的处理，但是资源仍然被开释掉了，这就分析智能指针解决了这个标题，那具体是如何实现的呢？
其实很简朴，它将开释资源这个任务交给了智能指针的生命周期了。当生命周期结束后，就会导致生命周期结束，调用析构函数，从而实现开释资源。因此不管是抛异常还是正常结束，都会导致其智能指针的对象的生命周期结束。
这个思路叫做RAII
3.1RAII

RAII（Resource Acquisition Is Initialization）是一种使用对象生命周期来控制程序资源（如内存、文件句柄、网络连接、互斥量等等）的简朴技术。
在对象构造时获取资源，接着控制对资源的访问使之在对象的生命周期内始终保持有用，最后在对象析构的时候开释资源。借此，我们现实上把管理一份资源的责任托管给了一个对象。这种做法有两大利益：

• 不必要显式地开释资源
  
• 采用这种方式，对象所需的资源在其生命期内始终保持有用。
  

RAII是一种托管资源的方式，智能指针使用了这个方案实现。雷同这样的方案还要c++线程库里之前所使用过的，下图所示：

3.2智能指针的原理

上述的SmartPtr还不能算是智能指针，由于它还不具有指针的举动。指针可以解引用，也可 以通过->去访问所指空间中的内容，如:SmartPtr<int> sp2(new int);的环境下，就无法访问不了该指针所指向的内容了，这个时候就要重载*和->，这样就可以访问了

1. template<class T>
2. class SmartPtr
3. {
4. public:
5.         SmartPtr(T* ptr)
6.                 :_ptr(ptr)
7.         {}
9.         ~SmartPtr()
10.         {
11.                 if (_ptr)
12.                 {
13.                         cout << "delete: " << _ptr << endl;
14.                         delete _ptr;
15.                 }
16.         }
18.         T& operator*()
19.         {
20.                 return *_ptr;
21.         }
23.         T* operator->()
24.         {
25.                 return _ptr;
26.         }
28. private:
29.         T* _ptr;
30. };

复制代码

测试代码：

1. void Func()
2. {
3.         SmartPtr<int> sp2(new int);
4.         *sp2 = 10;
5.         SmartPtr<pair<int, int>> sp3(new pair<int, int>);
6.         sp3->first = 1; //这里其实是两个->，但是编译器优化成一个->了，这之前讲过了
7.         sp3->second = 2;
9. }

复制代码

总结一下智能指针的原理：

• RAII特性
  
• 重载operator*和opertaor->，具有像指针一样的举动。
  

3.3智能指针的坑

但是这样还是不能称上完备的智能指针，只能说是最简朴的智能指针。会有很多坑，比如拷贝构造。
如果在代码中直接实行拷贝构作育会报错

1.         SmartPtr<int> sp4(new int); //拷贝构造
2.         SmartPtr<int> sp5 = sp4;

复制代码

为什么？之前写了这么多代码，和拷贝构造相干又能爆这个错误，其实就是这里是浅拷贝，又是指针，分析sp4和sp5指向了同一个空间，那么就会对同一个空间开释两次，就会导致程序崩b溃。
那怎么解决呢？——之前所采取的解决方案是用深拷贝，但是这里可以用深拷贝吗？其实是不行的，由于智能指针，我只是想使用你RAII的风格来解决我内存泄漏的标题，我只是将资源托管给你，在你生命周期结束之后可以或许开释资源，而不是擅自开一个空间来使用。
也就是说，智能指针的拷贝构作育应该像原生指针的举动p2 = p1一样，指向的是同一个空间，可是这样会导致瓦解。因此重点在解决析构同一个空间两次这个标题
其实这个标题之前在学习Linux文件系统的时候已经学过了，那就是引用计数【忘记了就要复习】
这里有三种解决方式：

• 管理权转移【这个方法不好】
  
• 防拷贝
  
• 引用计数
  

而c++里也是用这三个方式解决的，c++98用管理权转移(auto_ptr)解决， c++11提出了用防拷贝(unique_ptr)和引用计数解决
3.4 auto_ptr

C++98版本的库中就提供了auto_ptr的智能指针。下面演示的auto_ptr的使用及标题。 auto_ptr的实现原理：管理权转移的思想，下面简化模仿实现了一份auto_ptr来了解它的原理

1. namespace wzf
2. {
3.         template<class T>
4.         class auto_ptr
5.         {
6.         public:
7.                 auto_ptr(T* ptr)
8.                         :_ptr(ptr)
9.                 {
10.                 }
12.                 auto_ptr(auto_ptr<T>& sp)
13.                         :_ptr(sp._ptr)
14.                 {
15.                         // 管理权转移
16.                         sp._ptr = nullptr;
17.                 }
18.                 auto_ptr<T>& operator=(auto_ptr<T>& ap)
19.                 {
20.                         // 检测是否为自己给自己赋值
21.                         if (this != &ap)
22.                         {
23.                                 // 释放当前对象中资源
24.                                 if (_ptr)
25.                                         delete _ptr;
27.                                 // 转移ap中资源到当前对象中
28.                                 _ptr = ap._ptr;
29.                                 ap._ptr = NULL;
30.                         }
31.                         return *this;
32.                 }
34.                 ~auto_ptr()
35.                 {
36.                         if (_ptr)
37.                         {
38.                                 cout << "delete:" << _ptr << endl;
39.                                 delete _ptr;
40.                         }
41.                 }
43.                 // 像指针一样使用
44.                 T& operator*()
45.                 {
46.                         return *_ptr;
47.                 }
49.                 T* operator->()
50.                 {
51.                         return _ptr;
52.                 }
54.         private:
55.                 T* _ptr;
57.         };
58.         // 结论：auto_ptr是一个失败设计，很多公司明确要求不能使用auto_ptr
59. }

复制代码

测试代码：

1. #include <memory>
2. int main()
3. {
4.         //首先是c++98的auto_ptr（转移管理权）
5.         std::auto_ptr<int> sp1(new int);
6.         std::auto_ptr<int> sp2(sp1); // 管理权转移
8.         // sp1悬空
9.         *sp2 = 10;
10.         cout << *sp2 << endl;
11.         //cout << *sp1 << endl; //已经被置空了，无法在操作sp1
13.         return 0;
14. }

复制代码

这个方案并不是很好，由于它并没有完全模仿原生指针的举动，它是将sp1管理的资源(指针)，直接赋值给sp2，然后将sp1置空。**即让sp2管理资源，自己不管了，这样就不会析构同一个空间两次了。**可以说是早期的计划缺点

3.5 unique_ptr

C++11中开始提供更靠谱的unique_ptr
unique_ptr文档
unique_ptr的实现原理：简朴粗暴的防拷贝，下面简化模仿实现了一份unique_ptr来了解它的原理

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

复制代码

防拷贝就是直接很简朴粗暴的不让拷贝构造了

3.6 shared_ptr

由于总有一些环境要用到拷贝构造，因此c++11又弄了一个支持拷贝构造的智能指针，采取的解决方案是引用计数

1. namespace wzf
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.                 //拷贝构造
13.                 shared_ptr(const shared_ptr<T>& sp)
14.                         :_ptr(sp._ptr)
15.                         , _pcount(sp._pcount)
16.                 {
17.                         ++(*_pcount); //指向同一个空间的指针变多了。++
18.                 }
20.                 shared_ptr<T>& operator=(const shared_ptr<T> sp)
21.                 {
22.                         if (this != &sp)
23.                         {
24.                                 if (_ptr)
25.                                 {
26.                                         // 由于要赋值，以为这this这个智能指针不能管理自己的资源了，要管理sp所指向的资源了
27.                                         //先释放掉原有的资源，然后再被赋值。
28.                                         // 但是这个释放不能简单的直接释放，要考虑引用计数
29.                                         (*_pcount)--;
30.                                         if ((*_pcount) == 0) //当减为0之后才能释放
31.                                         {
32.                                                 delete _ptr;
33.                                                 delete _pcount;
34.                                                 _ptr = nullptr;
35.                                                 _pcount = nullptr;
36.                                         }
37.                                 }
39.                                 _ptr = sp._ptr;
40.                                 _pcount = sp._pcount;
41.                                 ++(*_pcount);
42.                         }
44.                         return *this;
45.                 }
47.                 ~shared_ptr()
48.                 {
49.                         if (--(*_pcount) == 0 && _ptr)
50.                         {
51.                                 cout << "delete:" << _ptr << endl;
52.                                 delete _ptr;
53.                                 _ptr = nullptr;
55.                                 delete _pcount; //指针也要释放
56.                                 _pcount = nullptr;
57.                         }
58.                 }
60.                 T& operator*()
61.                 {
62.                         return *_ptr;
63.                 }
65.                 T* operator->()
66.                 {
67.                         return _ptr;
68.                 }
70.         private:
71.                 T* _ptr;
72.                 int* _pcount; //引用计数
73.         };
74. }

复制代码

要注意，这个引用计数，不能是静态成员，由于静态成员属于这类，一旦有一个对象不指向同一个空间，就会重置，这样是不对的
这里要用指针，动态的，对每一个不同的空间都有一个指针来做引用计数
测试代码：

1.         //c++11的引用计数
2.         wzf::shared_ptr<int> sp5(new int);
3.         wzf::shared_ptr<int> sp6(sp5);
4.         wzf::shared_ptr<int> sp7;
5.         sp7 = sp6;
6.         wzf::shared_ptr<int> sp8(new int);

复制代码

3. shared_ptr的线程安全标题

其实上面自己模仿实现的shared_ptr会存在线程安全标题，由于存在引用计数，对同一个空间++，–。因此一旦有多线程的操纵，就会存在线程安全的标题。
比如：有两个线程同时对一个shared_ptr进行拷贝构造，那么就会对引用计数都++。一旦拷贝构造的次数多了，由于++不是原子操纵，因此，一旦在++的时候出现线程切换，就可能出现两个线程++一次之后，引用计数只++了一次。这里不具体讲，忘记了就复习Linux——多线程—02
下面是一个例子：

1. //关于shared_ptr的线程安全问题【库里的shared_ptr肯定线程安全，这里说的是自己模拟实现的】
2. #include"shared_ptr.h"
3. #include<thread>
4. using namespace std;
5. int main()
6. {
7.         wzf::shared_ptr<int> sp(new int);
8.         cout << sp.use_count() << endl;
9.         int n = 2000;
11.         //若shared_ptr线程不安全【对引用计数++，--操作不是互斥的】，则下面是会出现线程安全问题的代码：
12.         thread t1([&](){
13.                 for (int i = 1; i <= n; i++)
14.                 {
15.                         wzf::shared_ptr<int> sp1(sp); //对sp进行一次拷贝构造
16.                 }
17.                 });
19.         thread t2([&](){
20.                 for (int i = 1; i <= n; i++)
21.                 {
22.                         wzf::shared_ptr<int> sp2(sp); //进行一次拷贝构造
23.                 }
24.                 });
26.         t1.join();
27.         t2.join();
29.         cout << sp.use_count() << endl;
31.         return 0;
32. }

复制代码

每次的实行结果都不肯定一样
出现线程安全标题标话，只会有两种可能，一个是++的时候+少了，–的时候不够-，导致析构同一个空间两次，程序瓦解，还要一种可能是–的时候-少了，导致–不到0，无法析构。
正常应该是会delete掉的
以是还得继续改造一下shared_ptr，让它变得线程安全才行
以下是改造之后线程安全的shared_ptr

1. namespace wzf
2. {
3.         //实现线程安全的shared_ptr
4.         template<class T>
5.         class shared_ptr
6.         {
7.         public:
8.                 shared_ptr(T* ptr = nullptr)
9.                         :_ptr(ptr)
10.                         , _pcount(new int(1))
11.                         ,_pmutex(new mutex)
12.                 {}
14.                 //拷贝构造
15.                 shared_ptr(const shared_ptr<T>& sp)
16.                         :_ptr(sp._ptr)
17.                         ,_pcount(sp._pcount)
18.                         ,_pmutex(sp._pmutex)
19.                 {
20.                         add_ref_count(); //指向同一个空间的指针变多了。++
21.                 }
23.                 shared_ptr<T>& operator=(const shared_ptr<T> sp)
24.                 {
25.                         if (this != &sp)
26.                         {
27.                                 if (_ptr)
28.                                 {
29.                                         // 由于要赋值，以为这this这个智能指针不能管理自己的资源了，要管理sp所指向的资源了
30.                                         //先释放掉原有的资源，然后再被赋值。
31.                                         // 但是这个释放不能简单的直接释放，要考虑引用计数
32.                                         release();
33.                                 }
35.                                 _ptr = sp._ptr;
36.                                 _pcount = sp._pcount;
37.                 _pmutex = sp._pmutex;
38.                                 add_ref_count();
39.                         }
41.                         return *this;
42.                 }
44.                 ~shared_ptr()
45.                 {
46.                         release();
47.                 }
49.                 T& operator*()
50.                 {
51.                         return *_ptr;
52.                 }
54.                 T* operator->()
55.                 {
56.                         return _ptr;
57.                 }
59.                 T* get()
60.                 {
61.                         return _ptr;
62.                 }
64.                 int use_count()
65.                 {
66.                         return (*_pcount);
67.                 }
69.         private:
70.                
71.                 void add_ref_count()
72.                 {
73.                         //为了保证线程安全，在对临界资源操作的时候，要给临界资源_pcount加锁
74.                         _pmutex->lock();
75.                         (*_pcount)++;
76.                         _pmutex->unlock();
77.                 }
79.                 void release()
80.                 {
81.                         //给临界区加锁
82.                         _pmutex->lock();
83.                         bool flag = false;
84.                         if (--(*_pcount) == 0 && _ptr)
85.                         {
86.                                 cout << "delete:" << _ptr << endl;
87.                                 delete _ptr;
88.                                 _ptr = nullptr;
90.                                 delete _pcount; //指针也要释放
91.                                 _pcount = nullptr;
93.                                 flag = true;
94.                         }
96.                         _pmutex->unlock();
97.                         //如果引用计数为0了，那么锁也要释放了
98.                         if (flag)
99.                         {
100.                                 delete _pmutex;
101.                                 _pmutex = nullptr;
102.                         }
103.                 }
105.                 T* _ptr;
106.                 int* _pcount; //引用计数
107.                 mutex* _pmutex;
108.         };
109. }

复制代码

此时线程安全之后，无论怎么实行上面谁人多线程的代码，都是正常的

4. shared_ptr的循环引用标题

1. // shared_ptr的循环引用问题
2. #include"shared_ptr.h"
3. class ListNode
4. {
5. public:
6.         int _val;
7.         wzf::shared_ptr<ListNode> _next;
8.         wzf::shared_ptr<ListNode> _prev;
10.         ~ListNode()
11.         {
12.                 cout << "~ListNode" << endl;
14.         }
15. };
17. int main()
18. {
19.         wzf::shared_ptr<ListNode> sp1(new ListNode);
20.         wzf::shared_ptr<ListNode> sp2(new ListNode);
22.         // shared_ptr的循环引用
23.         // 因为有一些时候，我们会相同智能指针来管理自定义类型，而在使用的过程中可能会出现给指针赋值的情况
24.         // 但是这个时候类内的指针域有可能是内置类型，无法完成赋值操作。这个时候就需要将指针域也用智能指针来管理
25.         // 但是这个时候就会触发循环引用的问题
26.         sp1->_next = sp2;
27.         sp2->_prev = sp1;
28.         // 前面我们说了对于shared_ptr来说赋值就是将当前空间交给对方一起管理。
29.         // 所以sp1管理着一个ListNode，这个ListNode的_next又管理着sp2，此时sp2的引用计数为2
30.         // sp2管理着一个ListNode，引用计数为1，然后该ListNnode的prev又管理着sp1，sp1的引用计数为2。
31.         // 因此在析构的时候，就无法析构，因为只会--一次，不为0就不析构。
32.         // 这个循环牵制对方的现象就叫做循环引用！
34.         return 0;
35. }

复制代码

循环引用分析：

• node1和node2两个智能指针对象指向两个节点，引用计数变成1，我们不必要手动delete。
  
• node1的_next指向node2，node2的_prev指向node1，引用计数变成2。
  
• node1和node2析构，引用计数减到1，但是_next还指向下一个节点。但是_prev还指向上一个节点。
  
• 也就是说_next析构了，node2就开释了。
  
• 也就是说_prev析构了，node1就开释了。
  
• 但是_next属于node的成员，node1开释了，_next才会析构，而node1由_prev管理，_prev属于node2成员，以是这就叫循环引用，谁也不会开释
  

这是shared_ptr的一个缺点，无法自己解决，只能通过其他方式来解决
那如何解决呢？
c++给了一个弱指针——weak_ptr
weak_ptr是专门用来解决shared_ptr的循环引用标题标，它的原理就是不引用计数，直接将shared_ptr的对象作为参数传给weak_ptr去构造，而weak_ptr不会对shared_ptr所指向的空间做引用计数，这样就不会存在循环引用的标题了

1. #include"shared_ptr.h"
2. class ListNode
3. {
4. public:
5.         int _val;
6.         //wzf::shared_ptr<ListNode> _next;
7.         //wzf::shared_ptr<ListNode> _prev;
8.        
9.         // 为了防止引用计数的问题，这里要用weak_ptr
10.         std::weak_ptr<ListNode> _next;
11.         std::weak_ptr<ListNode> _prev;
13.         ~ListNode()
14.         {
15.                 cout << "~ListNode" << endl;
17.         }
18. };
20. int main()
21. {
22.         //那这个问题要如何解决呢？
23.         //就是弱指针——weak_ptr
24.         std::shared_ptr<ListNode> sp1(new ListNode);
25.         std::shared_ptr<ListNode> sp2(new ListNode);
27.         sp1->_next = sp2;
28.         sp2->_next = sp1;
30.         return 0;
31. }

复制代码

5.C++11和boost中智能指针的关系

• C++ 98 中产生了第一个智能指针auto_ptr.
  
• C++ boost给出了更实用的scoped_ptr和shared_ptr和weak_ptr.
  
• C++ TR1，引入了shared_ptr等。不外注意的是TR1并不是尺度版。
  
• C++ 11，引入了unique_ptr和shared_ptr和weak_ptr。必要注意的是unique_ptr对应boost的scoped_ptr。而且这些智能指针的实现原理是参考boost中的实现的。
  

6.定制删除器

关于定制删除器：
起首智能指针默认的开释资源的处理方式都是delete _ptr；
在一些特殊场景下，单纯的一个delete _ptr，无法满足开释资源的需求了
下面的代码例子中会有讲

1. // 关于智能指针的一些补充————定制删除器
3. class A
4. {
5. public:
7.         ~A()
8.         {
9.                 cout << "~A()\n";
10.         }
12. private:
13.         int _a;
14. };
16. template<class T>
17. struct DeleteArr
18. {
19.         void operator()(T* p)
20.         {
21.                 delete[] p;
22.         }
23. };
25. template<class T>
26. struct Free
27. {
28.         void operator()(T* p)
29.         {
30.                 cout << "free()" << endl;
31.                 free(p);
32.         }
33. };
35. struct Fclose
36. {
37.         void operator()(FILE* p)
38.         {
39.                 cout << "fclose()" << endl;
40.                 fclose(p);
41.         }
42. };
44. int main()
45. {
46.          //为什么需要对智能指针定制一个删除器呢
47.          // 这是因为在一些特殊场景下，单纯的一个delete _ptr，无法满足释放资源的需求了
48.          // 下面是例子：
49.         shared_ptr<A> sp1(new A); //这个情况下，智能指针能够释放资源
50.         //DeleteArr<A> d;
51.         //shared_ptr<A> sp2(new A[5]); //这个情况下，就是报错，因为单纯的delete _ptr无法处理这个情况
52.         // 不仅是上面这个，下面这两种也会
53.         //shared_ptr<A> sp3((A*)malloc(sizeof(A)));
54.         //shared_ptr<FILE> sp4(fopen("test.txt", "r"));
56.         // 因此我们需要定制一个删除器，以便于处理当前这个情况
57.         // 具体要怎么做呢，就是传一个仿函数给shared_ptr,让它用仿函数来处理常规方式无法释放的类型的资源的释放
58.         shared_ptr<A> sp2(new A[5], DeleteArr<A>());
59.         // 对sp3就要传一个专门处理malloc的仿函数
60.         shared_ptr<A> sp3((A*)malloc(sizeof(A)), Free<A>());
61.         // 对sp4要传一个专门处理FILE*的仿函数
62.         shared_ptr<FILE> sp4(fopen("test.txt", "w"), Fclose());
64.         // 下面是程序执行的结果
65.         //        fclose()
66.         //        free()
67.         //        ~A()
68.         //        ~A()
69.         //        ~A()
70.         //        ~A()
71.         //        ~A()
72.         //        ~A()
74.         return 0;
75. }

复制代码

这里不是重点，了解即可
;
fclose§;
}
};
int main()
{
//为什么必要对智能指针定制一个删除器呢
// 这是由于在一些特殊场景下，单纯的一个delete _ptr，无法满足开释资源的需求了
// 下面是例子：
shared_ptr sp1(new A); //这个环境下，智能指针可以或许开释资源
//DeleteArr d;
//shared_ptr sp2(new A[5]); //这个环境下，就是报错，由于单纯的delete _ptr无法处理这个环境
// 不仅是上面这个，下面这两种也会
//shared_ptr sp3((A*)malloc(sizeof(A)));
//shared_ptr sp4(fopen(“test.txt”, “r”));

1. // 因此我们需要定制一个删除器，以便于处理当前这个情况
2. // 具体要怎么做呢，就是传一个仿函数给shared_ptr,让它用仿函数来处理常规方式无法释放的类型的资源的释放
3. shared_ptr<A> sp2(new A[5], DeleteArr<A>());
4. // 对sp3就要传一个专门处理malloc的仿函数
5. shared_ptr<A> sp3((A*)malloc(sizeof(A)), Free<A>());
6. // 对sp4要传一个专门处理FILE*的仿函数
7. shared_ptr<FILE> sp4(fopen("test.txt", "w"), Fclose());
9. // 下面是程序执行的结果
10. //        fclose()
11. //        free()
12. //        ~A()
13. //        ~A()
14. //        ~A()
15. //        ~A()
16. //        ~A()
17. //        ~A()
19. return 0;

复制代码

}

2. [外链图片转存中...(img-MBhVcbzm-1746854443683)]
4. 这里不是重点，了解即可

复制代码

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

继续阅读请点击广告