前言
我们以前在写C/C++的时候老提到一个词就是“内存泄漏”，但是内存泄漏是啥？我们并没有说过，本期我们将介绍他，并会介绍避免内存泄漏的重要角色那就是 智能指针！
目录
前言
1、内存泄漏
1.1 什么是内存泄漏
1.2 内存泄漏的分类
• 堆内存泄漏
• 系统资源泄漏
1.3 内存泄漏的避免
2、智能指针的使用以及原理
2.1 RAII
2.2 智能指针的原理
2.3 智能指针的介绍与简单实现
std::auto_ptr
std::unique_ptr
循环引用
std::weak_ptr
2.4 deleter
1、内存泄漏
1.1 什么是内存泄漏
内存泄漏是指：由于疏忽或错误造成 程序未能释放已经不使用的内存的情况！
内存泄漏并不是指内存在物理上消失，而是应用程序分配某段内存后，因为设计错误，失去了对该段错误的控制，因而造成内存的浪费！
内存泄漏的危害
如长期运行的程序出现内存泄漏，影响很大！例如：操作系统、后台服务等。这种长期的服务程序一旦出现内存泄漏，就会慢慢的响应变慢，最终卡死的情况！
举个内存泄漏的例子：
while (true)
{int* p = new int[10];// 只是申请// 后续忘记了释放
}假设这是一个长期的服务端的程序，那每次都会泄漏一点，时间一长了相应变慢，甚至卡死！
1.2 内存泄漏的分类
在C/C++的程序中，我们一般只关心两方面的内存泄漏：
• 堆内存泄漏
堆内存指的是程序运行中需要通过 maloc / calloc / realloc / new 等从堆区中分配内存块，用完后必须通过相应的 free / delete 删掉。假设程序的设计错误导致这部分内存没有释放，那么这部分空间除非进程结束的那一次清理回收，否则在程序运行时，这块空间不能在使用，此时就产生了 Heap Leak
• 系统资源泄漏
系统资源的泄漏指的是：程序使用系统分配的资源，比如：套接字、文件描述描述符、管道等没有使用相应的函数释放掉，导致系统资源的浪费，严重只能可导致系统能效减少，系统执行不稳定。
1.3 内存泄漏的避免
1、在写工程前良好的设计规范，养成良好的编码规范，申请内存空间用完记得释放。
这里也有意外，比如我们碰上以上时也有可能造成内存泄漏，此时就需要借助智能指针了（后面有例子）
2、采用 RAII 思想或者 智能指针 来管理资源
3、如果出了问题使用内存泄漏的检测工具检测！如：dmalloc 以及 VLD 等
总结：内存泄漏在C/C++中非常的常见，解决方案有两种： 1、事先预防性，如使用智能指针等 2、事后查错型。如泄漏检测工具！
2、智能指针的使用以及原理
在正式的介绍智能指针前，我们先来介绍一下 RAII 思想！
2.1 RAII
RAII（Resoure Acquistion Is Initalization）是一种 利用对象的生命周期来控制程序资源（如：内存、文件句柄、网络连接、互斥量等）的简单技术！
在对象构造时获取资源，接着控制对资源的访问让他在对象的生命周期内时钟保持有效，最后在对象析构的时候释放资源。借此，我们实际上把管理一份资源的责任委托给了一个对象。
这种做法有两大好处：
1、不需要显示的释放资源
2、采用这种方式，对象所需的资源在其生命周期内时钟保持有效
我们先来举一个可能内存泄漏的例子：
int div()
{int a, b;cin >> a >> b;if (b == 0)throw invalid_argument("除0错误");return a / b;
}void Func()
{int* p1 = new int;int* p2 = new int;cout << div() << endl;delete p1;delete p2;
}int main()
{try{Func();}catch (exception& e){cout << e.what() << endl;}catch(...){cout << "unkonwn error" << endl;}return 0;
}此时，可能出现出现异常的地方有三处！1、第一个 new 的时候抛异常 2、第二个new的时候抛异常 3、div 调用抛出异常！这三种情况都会导致p1和p2不能正确的delete，此时就会造成内存的泄漏！如何解决呢？
第一种方式：就是多层try-catch但是很不优雅！
第二种方式：可以使用 RAII 思想设计出一个专门管理指针资源的类，让他管理！
template<class T>
class SmartPtr
{
public:SmartPtr(T* ptr = nullptr):_ptr(ptr){}~SmartPtr(){if (_ptr)delete _ptr;}
private:T* _ptr;
};此时只需要将资源委托给SmartPtr这个类，就不会有问题了！原因是：当SmartPtr对象在构造时初始化，后面无论是正常还是异常退出都会将调用析构清理资源！
此时只需要写成这样：
void Func()
{SmartPtr<int> p1(new int);SmartPtr<int> p2(new int);cout << div() << endl;
}这其实就是智能指针的雏形！
2.2 智能指针的原理
上述的SmartPtr还不能称之为智能指针，因为他还不具备指针的行为！指针可以解引用、也可以用->去访问指向空间的内容！因此，我们还需要让其具备这些行为！其中库里面就是这样做的：重载 * 和 ->
所以我们先把上面的SmartPtr类先给完善一下
template<class T>
class SmartPtr
{
public:SmartPtr(T* ptr = nullptr):_ptr(ptr){}~SmartPtr(){if (_ptr)delete _ptr;}T& operator*(){return *_ptr;}T* operator->(){return _ptr;}private:T* _ptr;
};此时就可以和指针一样的访问了：
int main()
{SmartPtr<int> p1(new int(5));cout << *p1 << endl;*p1 = 100;cout << *p1 << endl;return 0;
}
这里实现的SmartPtr还有最后一个问题，那就是拷贝后的重复析构问题：
int main()
{SmartPtr<int> p1(new int(5));SmartPtr<int> p2(p1);//...return 0;
}这里我们没写拷贝构造那就是浅拷贝，符合指针的特点！但是这里是对象，所以有重复析构的问题！如何解决呢？待会下面我们看看人家库里面如何做的！
上述的这就是简单的智能指针的原理：
1、RAII 特性
2、重载operator*和 operator->，具有指针的一样的行为
2.3 智能指针的介绍与简单实现
标准库里面提供了四个智能指针：std::auto_ptr、std::unique_ptr、std::shared_ptr、std::weak_ptr
他们都包含在 <memory> 的头文件中
std::auto_ptr
C++98 版本的库中就是提供了 auto_ptr的智能指针。
他有如下的成员函数：
简单的用一下 ：
std::auto_ptr<int> p1(new int);
*p1 = 10;
cout << *p1 << endl;
*p1 = 100;
cout << *p1 << endl;
他是如何解决重复析构的问题的呢？
它里面提供了get的方法，可以获取它内部存的指针，我们可以看看：
std::auto_ptr<int> p1(new int(10));
std::auto_ptr<int> p2(p1);cout << p1.get() << endl;
cout << p2.get() << endl;
这里是直接将p1管理的指针给干成了nullptr了，而把p1的值给p2了！
注意：这里库里面都 不支持隐式类型的转换，就是这样：
std::auto_ptr<int> p1 = new int;//error
平时我们都是不建议/或者说是禁止使用这个 auto_ptr 智能指针！因为他有一个巨大的缺陷，就是它支持拷贝，但是拷贝后会把自己给干没！
std::auto_ptr<int> p1(new int(10));
std::auto_ptr<int> p2(p1);
cout << *p1 << endl;// error 非法访问这种拷贝把自己拷贝没的情况称为管理权转移，此时带来的问题就是将自己悬空了操作者很难发现/很容易误操作，所以很多公司的开发文档以及官方的文档都是说了不要使用！
我们以后不使用他，这里简单的使用一下以及需要了解一下它的底层是咋做的：
std::auto_ptr的实现原理：管理权限转移的思想！我们可以简单的模拟实现一下：
namespace cp
{template<class T>class auto_ptr{public:auto_ptr(T* ptr):_ptr(ptr){}auto_ptr(auto_ptr<T>& sp):_ptr(sp._ptr){// 管理权限的转移sp._ptr = nullptr;// 将原先的给释放了}auto_ptr<T>& operator=(auto_ptr<T>& ap){// 判断是不是给自己赋值if (this != &ap){// 释放当前的资源if (_ptr)delete _ptr;// 转移ap中的资源_ptr = ap._ptr;ap._ptr = nullptr;}return *this;}~auto_ptr(){if (_ptr){cout << "delete:" << _ptr << endl;delete _ptr;}}// 像指针一样使用T& operator*(){return *_ptr;}T* operator->(){return _ptr;}private:T* _ptr;};
}这里简单了解一下！这个一般都是禁止使用的！
std::unique_ptr
因为上面的auto_ptr 因为设计的不够好用，所以C++11提供了更靠谱的std::unique_ptr
unique_ptr的最大特点就是：防止拷贝！
我们先来用一下：
这里我们发现他多了一个D类型的default_delete的东西，这是定制删除器，后面介绍！另外，他还支持把一个数组也可以交给unique_ptr管理了！
它的成员有函数有：
这里和上面的auto_ptr一样的接口不在演示，我们演示一下operator bool和operator[] ：
unique_ptr<int[]> p1(new int[5]{1,2,3,4,5});
cout << p1[1] << endl;
if (p1)// operator boolcout << p1.get() << endl;
// release
p1.release();
if (p1)cout << p1.get() << endl;
elsecout << p1.get() << endl;
OK，使用很简单。我们下面简单模拟实现一个：实现思路：防止拷贝！
namespace cp
{template<class T>class unique_ptr{public:unique_ptr(T* ptr):_ptr(ptr){}~unique_ptr(){if (_ptr){cout << "delete:" << _ptr << endl;delete _ptr;}}// 像指针一样使用T& operator*(){return *_ptr;}T* operator->(){return _ptr;}// c++11的做法unique_ptr(const unique_ptr<T>& sp) = delete;unique_ptr<T>& operator=(const unique_ptr<T>& sp) = delete;// C++98的做法//private:// unique_ptr(const unique_ptr<T>& sp){//...}// unique_ptr<T>& operator=(const unique_ptr<T>& sp){//...}private:T* _ptr;};
}std::shared_ptr
上面的unique_ptr解决了auto_ptr的缺陷，但是实际中也是有可能需要拷贝的，所以C++11又提出了一个全能型的智能指针 shared_ptr
shared_ptr是平时最常用的智能指针，它支持拷贝但是没有多次析构的问题！
他是如何做到多次拷贝而不重复析构的呢？
其实它的底层是通过引用计数的东西实现的，拷贝一次引用计数++减少一个引用计数--当减到0的时候才去释放资源！
成员函数：
另外还有这个
它的作用是可以减少内存的碎片化！因为它里面有一个引用计数的东西，本质是一个内存空间，所以shared_ptr里面有两块空间，如果是构造出来的，这两块空间是不同地方的，如果有多个这样的对象，此时就会有很多的小的内存碎片，导致大块的内存开不出来！而make_shared不是把引用计数和_ptr分开的，而是把他们搞成一起！这样可以减少内存碎片的问题，提高内存的使用率！
OK，我们下面就简单的使用一下shared_ptr的接口：
shared_ptr<int[]> p1(new int[5]{ 1,2,3,4,5 });
shared_ptr<int[]> p2(p1);
shared_ptr<int[]> p3(p1);
cout << p1.use_count() << endl;// 获取引用计数
{shared_ptr<int[]> p3(p1);cout << p3.use_count() << endl;// 获取引用计数
}
cout << p1.use_count() << endl;// 获取引用计数
shared_ptr<int> p1 = make_shared<int>();
shared_ptr<int> p2(p1);
cout << p1.use_count() << endl;循环引用
shared_ptr唯一会存在的问题就是看造成循环引用！如下：
struct ListNode
{int _data;shared_ptr<ListNode> _prev;shared_ptr<ListNode> _next;~ListNode() { cout << "~ListNode()" << endl; }
};int main()
{shared_ptr<ListNode> l1(new ListNode);shared_ptr<ListNode> l2(new ListNode);l1->_next = l2;l2->_prev = l1;return 0;
}此时这个代码是有问题的，本来应该是最后l1和l2要销毁的，但是他们没有调析构，导致内存泄漏！
而我们把他两相互连接中的一个给屏蔽了，就不会有问题：
造成上述情况的根本原因是shared_ptr的循环引用问题！
为什么把l1和l2的相互指向中的一个给屏蔽了就没有问题？
原因很简单，当只有单按指向的的时候，其中一个的引用计数一定是1，所以当结束的时候即使没有析构，当另一个对象结束的时候也会析构，做到安全的释放！
例如下面这种：
如何解决上面的循环引用的问题呢？
解决方案有两个：第一是：将ListNode的前后指针域换成普通的指针 第二是：使用weak_ptr
先来看看换成普通指针：
struct ListNode
{int _data;ListNode* _prev;ListNode* _next;~ListNode() { cout << "~ListNode()" << endl; }
};int main()
{shared_ptr<ListNode> l1(new ListNode);shared_ptr<ListNode> l2(new ListNode);l1->_next = l2.get();l2->_prev = l1.get();return 0;
}
但这样写不够优雅，所以C++11又提供了一个weak_ptr的智能指针！
std::weak_ptr
weak_ptr是一种不参与资源管理的智能指针，其只存在三种构造函数：
1、无参默认构造，此时weak_ptr初始化为空指针
2、拷贝构造，拷贝其它weak_ptr
3、通过shared_ptr初始化，此时shared_ptr和weak_ptr指向同一块内存
当shared_ptr和weak_ptr指向同一块内存的时候，weak_ptr不会增加引用计数！
weak_ptr离开作用域的时候，不会释放自己指向的资源，其只负责访问资源
所以，上面的代码可以使用weak_ptr解决循环引用的问题：
struct ListNode
{int _data;weak_ptr<ListNode> _prev;weak_ptr<ListNode> _next;~ListNode() { cout << "~ListNode()" << endl; }
};int main()
{shared_ptr<ListNode> l1(new ListNode);shared_ptr<ListNode> l2(new ListNode);l1->_next = l2;l2->_prev = l1;return 0;
}此时的weak_ptr仅仅是和shared_ptr共同指向了一块资源，但是weak_ptr没有对资源做计数的++/--操作！
OK，使用就介绍到这里！
我们下面对shared_ptr和weak_ptr简单的模拟实现一下：
namespace cp
{template<class T>class shared_ptr{public:shared_ptr(T* ptr):_ptr(ptr), _pcount(new atomic<int>(1)){}shared_ptr(T* ptr): _ptr(ptr), _pcount(new atomic<int>(1)){}// sp2(sp1)shared_ptr(const shared_ptr<T>& sp):_ptr(sp._ptr), _pcount(sp._pcount){(*_pcount)++;}// sp1 = sp3;shared_ptr<T>& operator=(const shared_ptr<T>& sp){//if (this != &sp)if (_ptr != sp._ptr)// 推荐{this->release();_ptr = sp._ptr;_pcount = sp._pcount;++(*_pcount);}return *this;}void release(){if (--(*_pcount) == 0){// 最后一个管理的对象，释放资源delete _ptr;delete _pcount;}}~shared_ptr(){release();}int use_count(){return *_pcount;}T& operator*(){return *_ptr;}T* operator->(){return _ptr;}private:T* _ptr;// 这里的引用计数千万不能是局部/静态的，否则有问题atomic<int>* _pcount;// 这里可以使用互斥锁mutex，但是使用原子操作更加优雅};
}weak_ptr
// 简化版本的weak_ptr实现template<class T>class weak_ptr{public:weak_ptr():_ptr(nullptr){}weak_ptr(const shared_ptr<T>& sp):_ptr(sp.get()){}weak_ptr<T>& operator=(const shared_ptr<T>& sp){_ptr = sp.get();return *this;}T& operator*(){return *_ptr;}T* operator->(){return _ptr;}private:T* _ptr;};注意：这里使用互斥锁/原子操作的时候，虽然shared_ptr是线程安全的，但是它里面的引用计数的++/--的操作不是线程安全的，所以要保证他们的安全！
2.4 deleter
对于智能指针，有时候需要用特殊的方式来对资源释放，不如文件指针：
shared_ptr<FILE> fp(fopen("test.txt", "w"));
对于指针fp不能简单的 delete fp，而是期望通过 fclose(fp)，此时就需要我们自定删除操作了，也就是需要自定义删除器了！
自定义删除器unique_ptr和shared_ptr的还有点不一样，所以我们分开介绍！
shared_ptr
shared_ptr<T> p(new T, deleter_function);
其中, deleter_function是一个满足删除器要求的可调用对象，包括函数指针，仿函数，lambda三种。
比如通过lambda来完成文件的fclose:
shared_ptr<FILE> fp(fopen("test.txt", "w"), [](FILE* ptr) { fclose(ptr); });
也可以通过仿函数：
struct deleteFile
{void operator()(FILE* ptr){fclose(ptr);}
};int main()
{shared_ptr<FILE> fp(fopen("test.txt", "w"), deleteFile());return 0;
}
也就是说，对于shared_ptr，只需要把删除器的可调用对象，直接作为第二个参数传入即可。
unique_ptr
unique_ptr的删除器语法比较别扭，要求在模板参数中传入可调用对象的类型。
同样的，可调用对象支持函数指针，仿函数，lambda三种。
以刚刚的关闭文件为例：
1、函数指针
void deleteFunc(FILE* ptr)
{fclose(ptr);
}int main()
{unique_ptr<FILE, void(*)(FILE*)> fp2(fopen("test.txt", "w"), deleteFunc);return 0;
}
2、使用仿函数
struct deleteFile
{void operator()(FILE* ptr){fclose(ptr);}
};int main()
{unique_ptr<FILE, deleteFile> fp(fopen("test.txt", "w"), deleteFile());return 0;
}
仿函数的类型是deleteFile，即类名，作为unique_ptr的第二个模板参数。
3、lambda表达式
auto expression = [](FILE* ptr) { fclose(ptr); };
unique_ptr<FILE, decltype(expression)> fp(fopen("test.txt", "w"), expression);
这里, expression是一个lambda表达式，由于lambda的类型是随机的，只能通过decltype(expression)来检测类型，作为unique_ptr的第二个模板参数。
对上面的shared_ptr接入自定义删除器：
template<class T>class shared_ptr{public:shared_ptr(T* ptr):_ptr(ptr), _pcount(new atomic<int>(1)){}template<class D>shared_ptr(T* ptr, D del): _ptr(ptr), _pcount(new atomic<int>(1)), _del(del){}// sp2(sp1)shared_ptr(const shared_ptr<T>& sp):_ptr(sp._ptr), _pcount(sp._pcount){(*_pcount)++;}// sp1 = sp3;shared_ptr<T>& operator=(const shared_ptr<T>& sp){//if (this != &sp)if (_ptr != sp._ptr){this->release();_ptr = sp._ptr;_pcount = sp._pcount;++(*_pcount);}return *this;}void release(){if (--(*_pcount) == 0){// 最后一个管理的对象，释放资源//delete _ptr;_del(_ptr);delete _pcount;}}~shared_ptr(){release();}int use_count(){return *_pcount;}T& operator*(){return *_ptr;}T* operator->(){return _ptr;}private:T* _ptr;atomic<int>* _pcount;function<void(T*)> _del = [](T* ptr) {delete ptr; };};OK，本期就到这里，我们下期再见！
