C++_智能指针
目录
一、智能指针的使用场景、基本概念
（1）因为抛异常而出现的资源泄漏的情况
二、RAII和智能指针的设计思路
三、c++标准库智能指针以及使用
（1）几种智能指针的概念
auto_ptr
unique_ptr
weak_ptr
不是new出来的资源要怎么释放
其他要点
(2)智能指针的原理
六、内存泄漏
什么是内存泄漏，内存泄漏的危害
如何避免内存泄漏
一、智能指针的使用场景、基本概念
（1）因为抛异常而出现的资源泄漏的情况
看到这一段代码
double Divide(int a, int b)
{
if (b == 0)
{
throw string("Divide by zero condition!");
}
else
{
return double(a) / b;
}
}
void Func()
{
//申请了资源
//此时Divide里面抛异常了就走不到后面的delete[]，而是直接回到main中进行异常的捕获
//那么就出现了内存泄漏
int* arr1 = new int[10];
int* arr2 = new int[10];
int len = 0, time = 0;
cin >> len >> time;
Divide(len, time);
cout << "delete[] arr1" << endl;
cout << "delete[] arr2" << endl;
delete[] arr1;
delete[] arr2;
}
int main()
{
try
{
Func();
}
catch (const char* errmsg)
{
cout << errmsg << endl;
}
catch (const string errmsg)
{
cout << errmsg << endl;
}
catch (...)
{
cout << "Unkown errmsg" << endl;
}
return 0;
}在没有除0情况出现时，程序在调用了Divide后会继续在Func里面执行；已知Divide之前是申请了资源的此时就可以正常走到delete[]；
但是若是出现了除零情况，那么在Divide里面抛异常了就会直接返回到最近且匹配的catch也就是main里面的catch那么在Func函数里面调用Divide这行后面的代码就会因为抛异常而不会执行，那么就会出现资源没有被释放也就是内存泄漏的情况；
###解决方法：
在Func里面也设置异常捕捉的代码，捕捉之后先进行资源释放，之后再重新抛出异常给外层main处理，此时也可以解决：
改进代码：
double Divide(int a, int b)
{
if (b == 0)
{
throw string("Divide by zero condition!");
}
else
{
return double(a) / b;
}
}
void Func()
{
int* arr1 = new int[10];
int* arr2 = new int[10];
try
{
int len = 0, time = 0;
cin >> len >> time;
Divide(len, time);
}
catch(...)//中途捕捉异常进行资源释放
{
cout << "delete[] arr1" << endl;
cout << "delete[] arr2" << endl;
delete[] arr1;
delete[] arr2;
//重新抛出异常给原本应该处理异常的main处理
throw;
}
cout << "delete[] arr1" << endl;
cout << "delete[] arr2" << endl;
delete[] arr1;
delete[] arr2;
}
int main()
{
try
{
Func();
}
catch (const char* errmsg)
{
cout << errmsg << endl;
}
catch (const string errmsg)
{
cout << errmsg << endl;
}
catch (...)
{
cout << "Unkown errmsg" << endl;
}
return 0;
}
这样只能治标不治本，因为当上面的new也出现抛异常要怎么办？若是arr1抛异常那么情况正常，不会申请任何资源直接被main里面的catch捕捉；但是若是arr2new抛异常了，arr1需要被释放资源那么还要单独写一个释放arr1资源的try catch ；那么当有很多这样的资源申请时，为了避免内存泄漏那就要写很多针对于某种情况的try catch；这会十分复杂，为了解决这种问题，C++引入了智能指针。
二、RAII和智能指针的设计思路
RAII是resource requisition is initialization的缩写；这是一种管理资源类的设计思想，本质是一种利用对象的生命周期来管理获取到的动态资源，避免资源泄漏；这里的资源可以是内存、文件指针、网络连接、互斥锁等；
RAII在获取到资源时将资源委托一个对象，并且可以控制对资源的访问，资源在对象生命周期未结束时始终有效，最后在对象进行析构时释放资源，这样保证了资源的正常释放。
智能指针类除了满⾜RAII的设计思路，还要⽅便资源的访问，所以智能指针类还会想迭代器类⼀
样，重载
operator*/operator->/operator[]
等运算符，⽅便访问资源。
###针对于上面代码的智能指针的使用：
template<class T>
class Smart_Ptr
{
public:
Smart_Ptr(T* ptr)
:_ptr(ptr)//浅拷贝
{}
~Smart_Ptr()
{
cout << "delete[]" << endl;
delete _ptr;
}
T& operator *()
{
return *_ptr;
}
T* operator ->()
{
return _ptr;
}
T& operator [](const int i)
{
return _ptr[i];
}
private:
T* _ptr;
};
double Divide(int a, int b)
{
if (b == 0)
{
throw string("Divide by zero condition!");
}
else
{
return double(a) / b;
}
}
void Func()
{
Smart_Ptr<int> ptr1 = new int[10];
Smart_Ptr<int> ptr2 = new int[10];
int len = 0, time = 0;
cin >> len >> time;
Divide(len, time);
}
int main()
{
try
{
Func();
}
catch (const char* errmsg)
{
cout << errmsg << endl;
}
catch (const string errmsg)
{
cout << errmsg << endl;
}
catch (...)
{
cout << "Unkown errmsg" << endl;
}
return 0;
}这样即使出现除零情况抛异常了，直接回到main，也不会有资源泄漏；因为当抛异常回到一个函数时，这个链中间的函数会进行栈展开，这些栈展开函数内部的对象生命周期结束了会进行析构；那么在这里就是ptr1和ptr2会自动析构，那么申请的资源就不会泄漏了。
三、c++标准库智能指针以及使用
说明：智能指针确实可以解决上面的问题；不过智能指针最重要的部分就是它的拷贝；我们知道智能指针是管理申请的资源之后能方便资源释放的，若是出现了拷贝，我们希望的拷贝出来的智能指针也管理的是同一份资源；因为被拷贝出来的智能指针不可能凭空去管理另一份资源，也没有新的资源去被它管理，所以此时的拷贝是为了多个智能指针对象共同管理一份资源；那么必然是浅拷贝；但是浅拷贝在析构时就会出现同一份资源释放多次的问题，重要的就是如何解决这个问题
C++标准库中的智能指针都在<memory>这个头文件下面，我们包含<memory>就可以是使⽤了，
智能指针有好几种，除了weak_ptr他们都符合RAII和像指针⼀样访问的行为，原理上而言主要是解
决智能指针拷贝时的思路不同。
（1）几种智能指针的概念
auto_ptr
auto_ptr是C++98时设计出来的智能指针，他的特点是拷⻉时把被拷⻉对象的资源的管理权转移给 拷⻉对象，这是⼀个⾮常糟糕的设计，因为它会到被拷贝对象悬空，访问报错的问题，C++11设计 出新的智能指针后，强烈建议不要使⽤auto_ptr。其他C++11出来之前很多公司也是明令禁⽌使⽤ 这个智能指针的。
unique_ptr
unique_ptr
是C++11设计出来的智能指针，它的名字翻译出来是唯⼀指针，它的特点是不⽀持拷
⻉，只⽀持移动。如果不需要拷⻉的场景就⾮常建议使⽤它。
shared_ptr
shared_ptr
是C++11设计出来的智能指针，他的名字翻译出来是共享指针，他的特点是⽀持拷⻉，
也⽀持移动。如果需要拷⻉的场景就需要使⽤他了。底层是⽤引⽤计数的⽅式实现的。
weak_ptr
weak_ptr
是C++11设计出来的智能指针，他的名字翻译出来是弱指针，他完全不同于上⾯的智能指
针，他不⽀持RAII，也就意味着不能⽤它直接管理资源，weak_ptr的产⽣本质是要解决shared_ptr
的⼀个循环引⽤导致内存泄漏的问题。
weak_ptr起到的是一个辅助功能，帮助shared_ptr解决特出场景的错误的。
//简化版实现
template<class T>
class weak_ptr
{
public:
//支持空的构造函数
weak_ptr()
{}
weak_ptr(const shared_ptr<T>& sp)
:_ptr(sp.get())
{}
weak_ptr<T>& operator=(const shared_ptr<T>& sp)
{
_ptr = sp.get();
}
private:
T* _ptr = nullptr;
};不是new出来的资源要怎么释放
智能指针析构时默认是进⾏delete释放资源，这也就意味着如果不是new出来的资源，交给智能指
针管理，析构时就会崩溃。智能指针⽀持在构造时给⼀个删除器，所谓删除器本质就是⼀个可调⽤
对象，这个可调⽤对象中实现你想要的释放资源的⽅式，当构造智能指针时，给了定制的删除器，
在智能指针析构时就会调⽤删除器去释放资源。因为new[]经常使⽤，所以为了简洁⼀点，
unique_ptr和shared_ptr都特化了⼀份[]的版本，使⽤时
unique_ptr<Date[]> up1(new
Date[5]);shared_ptr<Date[]> sp1(new Date[5]);
就可以管理new []的资源。
自己使用智能指针时若不是new出来的对象就需要自己写仿函数或者函数指针或者lambda表达式传给删除器；
template<class T>
void DeleteArrayFunc(T* ptr)
{
delete[] ptr;
}
template<class T>
class DeleteArray
{
public:
void operator()(T* ptr)
{
delete[] ptr;
}
};
class Fclose
{
public:
void operator()(FILE* ptr)
{
std::cout << "fclose:" << ptr << std::endl;
fclose(ptr);
}
};
int main()
{
// 这样实现程序会崩溃
// unique_ptr<Date> up1(new Date[10]);
// shared_ptr<Date> sp1(new Date[10]);
// 解决⽅案1
// 因为new[]经常使⽤，所以unique_ptr和shared_ptr
// 实现了⼀个特化版本，这个特化版本析构时⽤的delete[]
std::unique_ptr<Date[]> up1(new Date[5]);
std::shared_ptr<Date[]> sp1(new Date[5]);
// 解决⽅案2
// 仿函数对象做删除器
//unique_ptr<Date, DeleteArray<Date>> up2(new Date[5], DeleteArray<Date>());
// unique_ptr和shared_ptr⽀持删除器的⽅式有所不同
// unique_ptr是在类模板参数⽀持的，shared_ptr是构造函数参数⽀持的
// 使⽤仿函数unique_ptr可以不在构造函数传递，因为仿函数类型构造的对象直接就可以调⽤
// 但是下⾯的函数指针和lambda的类型不可以
//仿函数
std::unique_ptr<Date,DeleteArray<Date>> up2(new Date[5]);
std::shared_ptr<Date> sp2(new Date[5],DeleteArray<Date>());
//函数指针
std::unique_ptr<Date, void(*)(Date*)> up3(new Date[5],DeleteArrayFunc<Date>);
std::shared_ptr<Date> sp3(new Date[5], DeleteArrayFunc<Date>);
//lambda表达式
auto delArrOBJ = [](Date* ptr) {delete ptr; };
std::unique_ptr<Date, decltype(delArrOBJ)> up4(new Date[5], delArrOBJ);
std::shared_ptr<Date> sp4(new Date[5], delArrOBJ);
//其他资源类型
std::unique_ptr<FILE, Fclose> up5(fopen("Test.cpp","r"), Fclose());
std::shared_ptr<FILE> sp5(fopen("Test1.cpp", "r"),Fclose());
std::shared_ptr<FILE> sp6(fopen("Test2.cpp", "r"), [](FILE* ptr)
{
std::cout << "fclose:" << ptr << std::endl;
fclose(ptr);
});
return 0;
}
其他要点
template <class T, class... Args> shared_ptr<T> make_shared
(Args&&... args);
shared_ptr
除了⽀持⽤指向资源的指针构造，还⽀持
make_shared
⽤初始化资源对象的值
直接构造。
shared_ptr
和
unique_ptr
都⽀持了operator bool的类型转换，如果智能指针对象是⼀个
空对象没有管理资源，则返回false，否则返回true，意味着我们可以直接把智能指针对象给if判断
是否为空。
shared_ptr
和
unique_ptr
都得构造函数都使⽤explicit 修饰，防⽌普通指针隐式类型转换
成智能指针对象。
int main()
{
//make_shared
std::shared_ptr<Date> sp1 = std::make_shared<Date>(100, 100, 100);
auto sp2 = std::make_shared<Date>(100, 100, 100);
//向operator bool 的类型转换
std::shared_ptr<Date> sp3 = std::make_shared<Date>(100, 100, 100);
std::shared_ptr<Date> sp4 = std::make_shared<Date>(100, 100, 100);
if (sp3)
std::cout << "sp3 is not nullptr" << std::endl;
else
std::cout << "sp3 is nullptr" << std::endl;
if (sp4)
std::cout << "sp4 is not nullptr" << std::endl;
else
std::cout << "sp4 is nullptr" << std::endl;
//explicit构造时不支持隐式类型转换
//std::shared_ptr<Date> sp5 = new Date(100,100,100);
std::shared_ptr<Date> sp5 (new Date(100, 100, 100));
return 0;
}
(2)智能指针的原理
也就是这样的：auto_ptr拷贝时先把作为拷贝模板的智能指针管理的资源交给被拷贝对象，之后再把作为拷贝模板的对象的管理资源成员变量的那个指针悬空，那么就进行了管理资源权的转移；此时之前的那个智能智能就再无法使用了
auto_ptr的实现：
template<class T>
class auto_ptr
{
public:
auto_ptr(T* ptr)
:_ptr(ptr)
{}
//拷贝构造
auto_ptr(auto_ptr<T>& ap)
:_ptr(ap._ptr)
{
ap._ptr = nullptr;
}
//赋值重载
auto_ptr<T>& operator=(auto_ptr<T>& ap)
{
if (_ptr != ap._ptr)//防止自我赋值
{
if (_ptr)//先释放原来的资源，因为被赋值之后也没有管理它的了
delete _ptr;
_ptr = ap._ptr;
ap._ptr = nullptr;
}
return *this;
}
~auto_ptr()
{
if (_ptr)
delete _ptr;
}
T& operator * ()
{
return *_ptr;
}
T* operator & ()
{
return _ptr;
}
private:
T* _ptr;
};
unique_ptr
template<class T>
class unique_ptr
{
public:
explicit unique_ptr(T* ptr)
:_ptr(ptr)
{}
//不持支拷贝构造和赋值重载
unique_ptr(unique_ptr<T>& up) = delete;
unique_ptr<T>& operator = (unique_ptr<T>& up) = delete;
//支持移动语义
unique_ptr(unique_ptr<T>&& up)
:_ptr(up._ptr)
{
up._ptr = nullptr;
}
unique_ptr<T>& operator = (unique_ptr<T>&& up)
{
if (_ptr != up._ptr)
{
if (_ptr)
delete _ptr;
_ptr = up._ptr;
up._ptr = nullptr;
}
return *this;
}
T* operator & ()
{
return _ptr;
}
T& operator * ()
{
return *_ptr;
}
private:
T* _ptr;
};shared_ptr
引用计数增加的计数器不能是静态成员变量，否则一个不是管理资源A的shared_ptr出现了，管理资源A的计数器也会++，因为静态成员变量为同一类模板实例化出来的对象所共有；
这里要使用动态开辟，也就是说，当一个shared_ptr被创建时，要为这个智能指针申请一份资源给计数器，那么拷贝构造，这个计数器就++，析构时计数器--，若是计数器减到0，那么就需要是释放管理的这份资源；
赋值重载时若是没有判断自我赋值的情况，当计数器为1时，--计数器，此时会释放资源，后面又用到*_cnt，那么就出现了空指针的解引用，（智能指针的地址和其成员变量_ptr地址一样）
template<class T>
class shared_ptr
{
public:
explicit shared_ptr(T* ptr)
:_ptr(ptr)
,_cnt(new int(1))//构造计数器就是1，代表此时新建了一个shared指针，并且这份资源开始被管理
{}
shared_ptr(shared_ptr<T>& sp)
:_ptr(sp._ptr)
,_cnt(sp._cnt)
{
//拷贝构造意味着多了一个管理这份资源的shared_ptr
//所以就让计数器++
++(*_cnt);
}
shared_ptr<T>& operator=(shared_ptr<T>& sp)
{
//赋值重载
//首先让_ptr的计数器--，并且若是--之后计数器为0，则释放资源
//接着让_ptr指向的资源为sp管理的资源，并且让对应的计数器++
//注意：可能出现自我赋值的情况，此时判断一下就行
if (_ptr != sp._ptr)
{
if (--(*_cnt) == 0)
{
//释放资源
delete[] _ptr;
delete _cnt;
_ptr = nullptr;
_cnt = nullptr;
}
//赋值
_ptr = sp._ptr;
_cnt = sp._cnt;
++(*_cnt);
}
return *this;
}
~shared_ptr()
{
--(*_cnt);
if (*_cnt == 0)
{
delete[] _ptr;
delete _cnt;
_ptr = nullptr;
_cnt = nullptr;
}
}
T* get() const
{
return _ptr;
}
int count_use()const
{
return *_cnt;
}
private:
T* _ptr;
int* _cnt;
};基本的实现之后，还得处理不是new出来的资源的情况；
首先shared_ptr处理这种情况是将针对特定释放资源的仿函数、lambda表达式一类的方法传递给构造函数的第二个参数，之后这个对象在析构时就调用这个方法；
那么因为不是类型，而是具体的参数，所以shared_ptr类模板还是只有一个模板参数，但是在这个类中，要实现一份构造函数的函数模板用来接收构造时传的方法类型，从而后序能够使用；
但是这个参数在拷贝或者赋值时也要传给其他shared_ptr对象，所以应该把这个删除器类型置为成员变量，这样就能拷贝和赋值了；
这个成员变量要给缺省，因为一般情况下都是处理new出来的资源，所以不会传删除器，默认的删除器用delete；缺省值给的是方法也就是仿函数、lambda表达式，但是些方法没有固定类型，所以可以用包装器function接收。
具体代码：
template<class T>
class shared_ptr
{
public:
explicit shared_ptr(T* ptr)
:_ptr(ptr)
, _cnt(new int(1))
{}
//支持有删除器的构造函数
template<class D>
shared_ptr(T* ptr, D del)
: _ptr(ptr)
, _cnt(new int(1))
, _del(del)
{}
shared_ptr(shared_ptr<T>& sp)
:_ptr(sp._ptr)
, _cnt(sp._cnt)
, _del(sp._del)
{
++(*_cnt);
}
shared_ptr<T>& operator=(shared_ptr<T>& sp)
{
//赋值重载
//首先让_ptr的计数器--，并且若是--之后计数器为0，则释放资源
//接着让_ptr指向的资源为sp管理的资源，并且让对应的计数器++
//注意：可能出现自我赋值的情况，此时判断一下就行
if (_ptr != sp._ptr)
{
if (--(*_cnt) == 0)
{
//释放资源
if (_ptr)
_del(_ptr);
if (_cnt)
delete _cnt;
_ptr = nullptr;
_cnt = nullptr;
}
//赋值
_ptr = sp._ptr;
_cnt = sp._cnt;
_del = sp._del;
++(*_cnt);
}
return *this;
}
~shared_ptr()
{
--(*_cnt);
if (*_cnt == 0)
{
if(_ptr)
_del(_ptr);
if(_cnt)
delete _cnt;
_ptr = nullptr;
_cnt = nullptr;
}
}
T* get() const
{
return _ptr;
}
int use_count()const
{
return *_cnt;
}
private:
T* _ptr;
int* _cnt;
std::function<void(T*)> _del = [](T* ptr) { delete ptr; };
};测试：
Test::shared_ptr<Date> sp1(new Date);
//拷贝构造
Test::shared_ptr<Date> sp2(sp1);
std::cout << "sp1: " << sp1.use_count() << std::endl;
//赋值重载
Test::shared_ptr<Date> sp3(new Date);
sp2 = sp3;
std::cout <<"sp1: " << sp1.use_count() << std::endl;
std::cout <<"sp3: " << sp3.use_count() << std::endl;
return 0;delete的时候会去调用析构函数，释放动态开辟的资源
其他资源的释放
Test::shared_ptr<FILE> sp4(fopen("Test.cpp", "r"), Fclose());
Test::shared_ptr<FILE> sp5(fopen("Test.cpp", "r"), [](FILE* ptr)
{ std::cout << "fclose" << std::endl; delete ptr; });
Test::shared_ptr<Date> sp6(new Date[3], [](Date* ptr) {delete[] ptr; });四、shared_ptr和weak_ptr
shared_ptr⼤多数情况下管理资源⾮常合适，⽀持RAII，也⽀持拷⻉。但是在循环引⽤的场景下会
导致资源没得到释放内存泄漏，所以我们要认识循环引⽤的场景和资源没释放的原因，并且学会使
⽤weak_ptr解决这种问题。
（1）shared_ptr循环引用
循环引用例子：
两个节点指针，用两个不同的shared管理，前面节点指针的next指向后一个，后面的prev指针指向前一个，又因为next和prev也是shared的类型，当它们指向一个节点是也就是相当于赋值重载，那么count_use也会增加；所以指向完毕之后，这两个节点的count_use就是2，在程序结束之后，进行析构，析构的是这两个节点，计数器只会-1，但是需要到0才会释放资源，那么此时资源就不会释放，内存泄漏了。
也就是原本只用一个shared管理节点，但是用shared类型的next或者prev指针再指向这个节点后，next或者prev也会管理这个节点，最后析构时会因为计数器没有减到0二不会释放资源
具体代码：
struct ListNode
{
int _data;
std::shared_ptr<ListNode> _next;
std::shared_ptr<ListNode> _prev;
//std::weak_ptr<ListNode> _next;
//std::weak_ptr<ListNode> _prev;
ListNode(int data = 0)
:_data(data)
{}
~ListNode()
{
std::cout << "~ListNode()" << std::endl;
}
};
int main()
{
std::shared_ptr<ListNode> n1(new ListNode(1));
std::shared_ptr<ListNode> n2(new ListNode(2));
std::cout << n1.use_count() << std::endl;
std::cout << n2.use_count() << std::endl;
n1->_next = n2;
n2->_prev = n1;
std::cout << n1.use_count() << std::endl;
std::cout << n2.use_count() << std::endl;
return 0;
}结果没有析构
将_next _prev的类型改为weak_ptr：
引用计数数字不变，智能指针析构时delete调用listNode的析构函数：
五、shared_ptr的线程安全
shared_ptr的引⽤计数对象在堆上，如果多个shared_ptr对象在多个线程中，进⾏shared_ptr的拷
⻉析构时会访问修改引⽤计数，就会存在线程安全问题，所以shared_ptr引⽤计数是需要加锁或者
原⼦操作保证线程安全的。
shared_ptr指向的对象也是有线程安全的问题的，但是这个对象的线程安全问题不归shared_ptr
管，它也管不了，应该有外层使⽤shared_ptr的⼈进⾏线程安全的控制。
下⾯的程序会崩溃或者A资源没释放，bit::shared_ptr引⽤计数从int*改成atomic<int>*就可以保证
引⽤计数的线程安全问题，或者使⽤互斥锁加锁也可以。
#include<thread>
struct AA
{
int _a1 = 0;
int _a2 = 0;
~AA()
{
std::cout << "~AA()" << std::endl;
}
};
int main()
{
Test::shared_ptr<AA> p(new AA);
const size_t n = 100000;
mutex mtx;
auto func = [&]()
{
for (size_t i = 0; i < n; ++i)
{
// 这⾥智能指针拷⻉会++计数
Test::shared_ptr<AA> copy(p);
{
unique_lock<mutex> lk(mtx);
copy->_a1++;
copy->_a2++;
}
}
};
std::thread t1(func);
std::thread t2(func);
t1.join();
t2.join();
std::cout << p->_a1 << std::endl;
std::cout << p->_a2 << std::endl;
std::cout << p.use_count() << std::endl;
return 0;
}shared_ptr本身是线程安全的，但是它管理的资源不是
六、内存泄漏
什么是内存泄漏，内存泄漏的危害
什么是内存泄漏：内存泄漏指因为疏忽或错误造成程序未能释放已经不再使⽤的内存，⼀般是忘记释放或者发⽣异常释放程序未能执⾏导致的。内存泄漏并不是指内存在物理上的消失，⽽是应⽤程序分配某段内存后，因为设计错误，失去了对该段内存的控制，因⽽造成了内存的浪费。
内存泄漏的危害：普通程序运⾏⼀会就结束了出现内存泄漏问题也不⼤，进程正常结束，⻚表的映射关系解除，物理内存也可以释放。⻓期运⾏的程序出现内存泄漏，影响很⼤，如操作系统、后台服务、⻓时间运⾏的客⼾端等等，不断出现内存泄漏会导致可⽤内存不断变少，各种功能响应越来越慢，最终卡死。
如何避免内存泄漏
⼯程前期良好的设计规范，养成良好的编码规范，申请的内存空间记着匹配的去释放。ps：这个理
想状态。但是如果碰上异常时，就算注意释放了，还是可能会出问题。需要下⼀条智能指针来管理
才有保证。
尽量使⽤智能指针来管理资源，如果⾃⼰场景⽐较特殊，采⽤RAII思想⾃⼰造个轮⼦管理。
定期使⽤内存泄漏⼯具检测，尤其是每次项⽬快上线前，不过有些⼯具不够靠谱，或者是收费。
总结⼀下：内存泄漏⾮常常⻅，解决⽅案分为两种：1、事前预防型。如智能指针等。2、事后查错
型。如泄漏检测⼯具。