前言
我们以前在写C/C++的时候老提到一个词就是**"内存泄漏"** ，但是内存泄漏是啥？我们并没有说过，本期我们将介绍他，并会介绍避免内存泄漏的重要角色那就是 智能指针！
目录
[1.1 什么是内存泄漏](#1.1 什么是内存泄漏)
[1.2 内存泄漏的分类](#1.2 内存泄漏的分类)
[• 堆内存泄漏](#• 堆内存泄漏)
[• 系统资源泄漏](#• 系统资源泄漏)
[1.3 内存泄漏的避免](#1.3 内存泄漏的避免)
[2.1 RAII](#2.1 RAII)
[2.2 智能指针的原理](#2.2 智能指针的原理)
[2.3 智能指针的介绍与简单实现](#2.3 智能指针的介绍与简单实现)
[2.4 deleter](#2.4 deleter)
1、内存泄漏
1.1 什么是内存泄漏
内存泄漏 是指：由于疏忽或错误造成 程序未能释放已经不使用的内存的情况！
内存泄漏并不是指内存在物理上消失，而是应用程序分配某段内存后，因为设计错误，失去了对该段错误的控制，因而造成内存的浪费！
内存泄漏的危害
如长期运行的程序出现内存泄漏，影响很大！例如：操作系统、后台服务等。这种长期的服务程序一旦出现内存泄漏，就会慢慢的响应变慢，最终卡死的情况！
举个内存泄漏的例子：
cpp
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 （R esoure A cquistion I s I nitalization）是一种 利用对象的生命周期来控制程序资源 （如：内存 、文件句柄 、网络连接 、互斥量 等）的简单技术！
在对象构造时获取资源 ，接着控制对资源的访问让他在对象的生命周期内时钟保持有效，最后在对象析构的时候释放资源。借此，我们实际上把管理一份资源的责任委托给了一个对象。
这种做法有两大好处：
1、不需要显示的释放资源
2、采用这种方式，对象所需的资源在其生命周期内时钟保持有效
我们先来举一个可能内存泄漏的例子：
cpp
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 思想设计出一个专门管理指针资源的类，让他管理！
cpp
template<class T>
class SmartPtr
{
public:
SmartPtr(T* ptr = nullptr)
:_ptr(ptr)
{}
~SmartPtr()
{
if (_ptr)
delete _ptr;
}
private:
T* _ptr;
};此时只需要将资源委托给SmartPtr这个类，就不会有问题了！原因是：当SmartPtr对象在构造时初始化，后面无论是正常还是异常退出都会将调用析构清理资源！
此时只需要写成这样：
cpp
void Func()
{
SmartPtr<int> p1(new int);
SmartPtr<int> p2(new int);
cout << div() << endl;
}这其实就是智能指针的雏形！
2.2 智能指针的原理
上述的SmartPtr还不能称之为智能指针，因为他还不具备指针的行为！指针可以解引用、也可以用->去访问指向空间的内容！因此，我们还需要让其具备这些行为！其中库里面就是这样做的：重载 * 和 ->
所以我们先把上面的SmartPtr类先给完善一下
cpp
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;
};此时就可以和指针一样的访问了：
cpp
int main()
{
SmartPtr<int> p1(new int(5));
cout << *p1 << endl;
*p1 = 100;
cout << *p1 << endl;
return 0;
}
这里实现的SmartPtr还有最后一个问题，那就是拷贝后的重复析构问题：
cpp
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的智能指针。
他有如下的成员函数：
简单的用一下 ：
cpp
std::auto_ptr<int> p1(new int);
*p1 = 10;
cout << *p1 << endl;
*p1 = 100;
cout << *p1 << endl;
他是如何解决重复析构的问题的呢？
它里面提供了get的方法，可以获取它内部存的指针，我们可以看看：
cpp
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了！
注意 ：这里库里面都 不支持隐式类型的转换，就是这样：
cpp
std::auto_ptr<int> p1 = new int;//error
平时我们都是不建议/或者说是禁止使用这个 auto_ptr 智能指针！因为他有一个巨大的缺陷，就是它支持拷贝，但是拷贝后会把自己给干没！
cpp
std::auto_ptr<int> p1(new int(10));
std::auto_ptr<int> p2(p1);
cout << *p1 << endl;// error 非法访问这种拷贝把自己拷贝没的情况称为管理权转移，此时带来的问题就是将自己悬空了操作者很难发现/很容易误操作，所以很多公司的开发文档以及官方的文档都是说了不要使用！
我们以后不使用他，这里简单的使用一下以及需要了解一下它的底层是咋做的：
**std::auto_ptr的实现原理：管理权限转移的思想！**我们可以简单的模拟实现一下：
cpp
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[] ：
cpp
unique_ptr<int[]> p1(new int[5]{1,2,3,4,5});
cout << p1[1] << endl;
if (p1)// operator bool
cout << p1.get() << endl;
// release
p1.release();
if (p1)
cout << p1.get() << endl;
else
cout << p1.get() << endl;
OK，使用很简单。我们下面简单模拟实现一个：实现思路：防止拷贝！
cpp
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的接口：
cpp
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;// 获取引用计数
cpp
shared_ptr<int> p1 = make_shared<int>();
shared_ptr<int> p2(p1);
cout << p1.use_count() << endl;循环引用
shared_ptr 唯一会存在的问题就是看造成循环引用！如下：
cpp
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**
先来看看换成普通指针：
cpp
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解决循环引用的问题：
cpp
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简单的模拟实现一下：
cpp
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
cpp
// 简化版本的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
对于智能指针，有时候需要用特殊的方式来对资源释放，不如文件指针：
cpp
shared_ptr<FILE> fp(fopen("test.txt", "w"));对于指针fp 不能简单的delete fp ，而是期望通过 fclose(fp) ，此时就需要我们自定删除操作了，也就是需要自定义删除器了！
自定义删除器unique_ptr 和shared_ptr的还有点不一样，所以我们分开介绍！
shared_ptr
cpp
shared_ptr<T> p(new T, deleter_function);其中, deleter_function 是一个满足删除器要求的可调用对象，包括函数指针，仿函数，****lambda三种。
比如通过lambda来完成文件的fclose:
cpp
shared_ptr<FILE> fp(fopen("test.txt", "w"), [](FILE* ptr) { fclose(ptr); });也可以通过仿函数：
cpp
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、函数指针
cpp
void deleteFunc(FILE* ptr)
{
fclose(ptr);
}
int main()
{
unique_ptr<FILE, void(*)(FILE*)> fp2(fopen("test.txt", "w"), deleteFunc);
return 0;
}2、使用仿函数
cpp
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表达式
cpp
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接入自定义删除器：
cpp
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，本期就到这里，我们下期再见！