目录
为什么需要智能指针
抛异常引发内存泄漏
内存泄漏
什么是内存泄漏，内存泄漏的危害
内存泄漏分类
检测内存泄漏常用工具
如何避免内存泄漏
智能指针的使用及原理
RAII
智能指针的原理
各类智能指针介绍
auto_ptr
unique_ptr
weak_ptr
定制删除器
为什么需要智能指针
抛异常引发内存泄漏
对于下面这段代码，存在什么问题？
int div()
{
int a, b;
cin >> a >> b;
if (b == 0)
throw invalid_argument("除0错误");
return a / b;
}
void Func()
{
// 1、如果p1这里new 抛异常会如何？
// 2、如果p2这里new 抛异常会如何？
// 3、如果div调用这里又会抛异常会如何？
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;
}
return 0;
}分析上述代码，如果在p1处抛异常，代码直接跳转到main函数中捕获异常，不会造成资源泄漏。但是如果在p2被new时，或者调用div()函数时抛异常，代码跳转到main()函数，两个delete语句会被跳过，导致内存泄漏。
内存泄漏
什么是内存泄漏，内存泄漏的危害
内存泄漏
内存泄漏指因为疏忽或错误造成程序未能释放已经不再使用的内存的情况。内存泄漏并不是指内存在物理上的消失，而是应用程序分配某段内存后，因为设计错误，失去了对该段内存的控制，因而造成了内存的浪费。
内存泄漏的危害
长期运行的程序出现内存泄漏，影响很大，如操作系统、后台服务等等，出现内存泄漏会导致响应越来越慢，最终卡死。
常见的内存泄漏
void MemoryLeaks()
{
// 1.内存申请了忘记释放
int* p1 = (int*)malloc(sizeof(int));
int* p2 = new int;
// 2.异常安全问题
int* p3 = new int[10];
Func(); // 这里Func函数抛异常导致 delete[] p3未执行，p3没被释放.
delete[] p3;
}内存泄漏分类
C/C++程序中一般我们关心两种方面的内存泄漏：
- 堆内存泄漏(Heap leak):堆内存指的是程序执行中依据须要分配通过malloc / calloc / realloc / new等从堆中分配的一块内存，用完后必须通过调用相应的free或者delete删掉。假设程序的设计错误导致这部分内存没有被释放，那么以后这部分空间将无法再被使用，就会产生Heap Leak。
- 系统资源泄漏:指程序使用系统分配的资源，比方套接字、文件描述符、管道等没有使用对应的函数释放掉，导致系统资源的浪费，严重可导致系统效能减少，系统执行不稳定。
检测内存泄漏常用工具
以下几种工具可以用来帮助检测是否存在内存泄漏
- 在Linux下内存泄漏检测：Memory Debuggers - eLinux.org
- 在windows下使用第三方工具检测：VLD(Visual LeakDetector)内存泄露库
- 其他检测工具比较：内存泄露检测工具比较 - 默默淡然 - 博客园 (cnblogs.com)
如何避免内存泄漏
- 工程前期良好的设计规范，养成良好的编码规范，申请的内存空间记着匹配的去释放。这个理想状态。但是如果碰上异常时，就算注意释放了，还是可能会出问题。需要下一条智能指针来管理才有保证。
- 采用RAII思想或者智能指针来管理资源（后面将要介绍的智能指针即采用RAII思想）
- 有些公司内部规范使用内部实现的私有内存管理库。这套库自带内存泄漏检测的功能选项
- 出问题了使用内存泄漏工具检测
【总结】
内存泄漏非常常见，解决方案分为两种：1、事前预防型：如智能指针等。 2、事后查错型：“如泄漏检测工具。
智能指针的使用及原理
RAII
RAII（Resource Acquisition Is Initialization）是一种利用对象生命周期来控制程序资源（如内
存、文件句柄、网络连接、互斥量等等）的简单技术。
在对象构造时获取资源，接着控制对资源的访问使之在对象的生命周期内始终保持有效，最后在
对象析构的时候释放资源。借此，我们实际上把管理一份资源的责任托管给了一个对象。这种做
法有两大好处：
- 不需要显式地释放资源。
- 采用这种方式，对象所需的资源在其生命期内始终保持有效
// 使用RAII思想设计的SmartPtr类
template<class T>
class SmartPtr {
public:
SmartPtr(T* ptr = nullptr)
: _ptr(ptr)
{}
~SmartPtr()
{
if (_ptr)
delete _ptr;
}
private:
T* _ptr;
};智能指针的原理
上述的SmartPtr还不能将其称为智能指针，上述模拟实习的智能指针只用到了RAII的思想，即构造对象时获取资源、析构对象时回收资源，但是它还不具有指针的行为。指针可以解引用，也可以通过->去访问所指空间中的内容，因此：AutoPtr模板类中还得需要将* 、->重载下，才可让其像指针一样去使用。
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;
};总结一下智能指针的原理：
- RAII特性
- 重载operator*和opertaor->，具有像指针一样的行为
各类智能指针介绍
auto_ptr
早在C++98中就已经出现了智能指针的概念，同时库中也提供了auto_ptr的智能指针。当时采用的是管理权转移的思想，下面简化模拟实现了一份auto_ptr来了解它的原理。
template<class T>
class auto_ptr
{
public:
//RAII
//保存资源
auto_ptr(T* ptr)
:_ptr(ptr)
{}
//释放资源
~auto_ptr()
{
delete _ptr;
}
//auto_ptr采用资源管理权转移 -- 但是会导致对象悬空
auto_ptr(auto_ptr<T>& sp)
:_ptr(sp._ptr)
{
sp._ptr = nullptr;
}
//智能指针要有指针的功能
T& operator*()
{
return *_ptr;
}
T* operator->()
{
return _ptr;
}
T& operator[](size_t pos)
{
return _ptr[pos];
}
private:
T* _ptr;
};auto_ptr采用了RAII思想，可以解决抛异常引发的内存泄漏问题，但同时又造成了新的问题。auto_ptr在实现拷贝构造函数时采用了管理权转移的方式。
相信大伙一眼就能看出这种实现思想有很坑的一点，用一个旧的指针去构造一个新的指针之后，只有新的指针指向了内容，旧的指针指向了空，但我们仍可能去解引用旧的指针啊。例如下面的例子一定会引发错误。
void test_auto()
{
auto_ptr<int> ap1(new int(1));
auto_ptr<int> ap2(ap1);
*ap1 = 1; // 管理权转移以后导致ap1悬空，不能访问
*ap2 = 1;
}
auto_ptr这一问题也是被骂了很长时间，C++标准委员会也是直接表明不要使用auto_ptr。
unique_ptr
unique_ptr是C++11标准库提供的一个靠谱的智能指针，unique_ptr既体现了RAII的思想，同时也没有auto_ptr的问题，因为它直接就没有拷贝构造函数。
unique_ptr的实现原理：简单粗暴的防拷贝，下面简化模拟实现了一份unique_ptr来了解它的原理。
template<class T>
class unique_ptr
{
public:
//RAII
//保存资源
unique_ptr(T* ptr)
:_ptr(ptr)
{}
//释放资源
~auto_ptr()
{
delete _ptr;
}
//智能指针要有指针的功能
T& operator*()
{
return *_ptr;
}
T* operator->()
{
return _ptr;
}
T& operator[](size_t pos)
{
return _ptr[pos];
}
//C++11:可以用=delete直接封死拷贝构造和赋值构造
unique_ptr(const unique_ptr<T>& up) = delete;
unique_ptr<T>& operator=(const unique_ptr<T>& up) = delete;
private:
//防拷贝
// 拷贝构造和赋值是默认成员函数，我们不写会自动生成，所以我们不需写
// C++98思路：只声明不实现，但是用的人可能会在外面强行定义，所以再加一条，声明为私有
//unique_ptr(const unique_ptr<T>& up);
//unique_ptr<T>& operator=(const unique_ptr<T>& up);
T* _ptr;
};
shared_ptr
C++11中除了提供了unique_ptr还提供更靠谱的并且支持拷贝的shared_ptr。
shared_ptr的原理：是通过引用计数的方式来实现多个shared_ptr对象之间共享资源。
- shared_ptr在其内部，给每个资源都维护了着一份计数，用来记录该份资源被几个对象共
享。 - 在对象被销毁时(也就是析构函数调用)，就说明自己不使用该资源了，对象的引用计数减
一。 - 如果引用计数是0，就说明自己是最后一个使用该资源的对象，必须释放该资源。
- 如果不是0，就说明除了自己还有其他对象在使用该份资源，不能释放该资源，否则其他对
象就成野指针了。
实现拷贝构造时采用引用计数的方式，在实现赋值重载时，要注意等号左边的指针指向的内容是否需要被释放。
情况一：
情况二：
shared_ptr具体实现代码：
template<class T>
class shared_ptr {
public:
//RAII
//保存资源
shared_ptr(T* ptr)
:_ptr(ptr)
,_pcount(new int(1))
{}
//释放资源
~shared_ptr()
{
Release();
}
shared_ptr(const shared_ptr<T>& sp)
:_ptr(sp._ptr)
, _pcount(sp._pcount)
{
AddCount();
}
shared_ptr<T>& operator=(const shared_ptr<T>& sp)
{
if (sp._ptr != _ptr)
{
Release();
_ptr = sp._ptr;
_pcount = sp._pcount;
AddCount();
}
return *this;
}
void Release()
{
if (--(*_pcount) == 0)
{
delete _ptr;
delete _pcount;
}
}
void AddCount()
{
++(*_pcount);
}
T& operator*()
{
return *_ptr;
}
T* operator->()
{
return _ptr;
}
private:
T* _ptr;
int* _pcount;
};上述的代码已经可以满足一般的应用场景，但是设计到多线程操作时，上面的shared_ptr存在线程安全的问题，所以我们最好还是实现通过加锁实现一个线程安全的版本。
template<class T>
class shared_ptr {
public:
//RAII
//保存资源
shared_ptr(T* ptr)
:_ptr(ptr)
,_pcount(new int(1))
,_pmtx(new mutex)
{}
//释放资源
~shared_ptr()
{
Release();
}
shared_ptr(const shared_ptr<T>& sp)
:_ptr(sp._ptr)
, _pcount(sp._pcount)
,_pmtx(sp._pmtx)
{
AddCount();
}
shared_ptr<T>& operator=(const shared_ptr<T>& sp)
{
if (sp._ptr != _ptr)
{
Release();
_ptr = sp._ptr;
_pcount = sp._pcount;
_pmtx = sp._pmtx;
AddCount();
}
return *this;
}
void Release()
{
_pmtx->lock();
if (--(*_pcount) == 0)
{
delete _ptr;
delete _pcount;
}
_pmtx->unlock();
}
void AddCount()
{
_pmtx->lock();
++(*_pcount);
_pmtx->unlock();
}
T& operator*()
{
return *_ptr;
}
T* operator->()
{
return _ptr;
}
T* get()
{
return _ptr;
}
int use_count()
{
return *_pcount;
}
private:
T* _ptr;
int* _pcount;
mutex* _pmtx;
};weak_ptr
循环引用的情况：
比如上面这个双向链表，我们一般就是这样使用，但是因为抛异常可能导致内存泄漏的问题，于是我们改用智能指针。n1和n2不构成循环时可以正常使用智能指针。
n1和n2构成循环引用时，智能指针无法释放空间，造成内存泄漏。
原因是
- 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成员，所以这就叫循环引用，谁也不会释放。
解决方案：在引用计数的场景下，把节点中的_prev和_next改成weak_ptr就可以了
weak_ptr原理就是，node1->_next = node2;和node2->_prev = node1;时weak_ptr的_next和
_prev不会增加node1和node2的引用计数。
【注意】
weak_ptr不是常规的智能指针，不支持RAII ，但是它支持像指针一样
专门设计出来，辅助解决shared_ptr的循环引用问题，
weak_ptr可以指向资源，但是他不参与管理，不增加引用计数
template<class T>
class weak_ptr
{
public:
weak_ptr()
:_ptr(nullptr)
{}
weak_ptr(const shared_ptr<T>& sp)
:_ptr(sp.get())
{}
T& operator*()
{
return *_ptr;
}
T* operator->()
{
return _ptr;
}
T* get()
{
return _ptr;
}
private:
T* _ptr;
};shared_ptr和weak_ptr配合使用就可以解决循环引用的问题了。
定制删除器
如果不是new出来的对象如何通过智能指针管理呢？其实shared_ptr设计了一个删除器来解决这
个问题。
// 仿函数的删除器
template<class T>
struct FreeFunc {
void operator()(T* ptr)
{
cout << "free:" << ptr << endl;
free(ptr);
}
};
template<class T>
struct DeleteArrayFunc {
void operator()(T* ptr)
{
cout << "delete[]" << ptr << endl;
delete[] ptr;
}
};定制删除器版本shared_ptr
template<class T>
class shared_ptr
{
public:
shared_ptr(T* ptr = nullptr)
:_ptr(ptr)
, _pcount(new int(1))
, _pmtx(new mutex)
{}
template<class D>
shared_ptr(T* ptr, D del)
: _ptr(ptr)
, _pcount(new int(1))
, _pmtx(new mutex)
, _del(del)
{}
~shared_ptr()
{
Release();
}
void Release()
{
_pmtx->lock();
bool deleteFlag = false;
if (--(*_pcount) == 0)
{
if (_ptr)
{
//cout << "delete:" << _ptr << endl;
//delete _ptr;
// 删除器进行删除
_del(_ptr);
}
delete _pcount;
deleteFlag = true;
}
_pmtx->unlock();
if (deleteFlag)
{
delete _pmtx;
}
}
void AddCount()
{
_pmtx->lock();
++(*_pcount);
_pmtx->unlock();
}
shared_ptr(const shared_ptr<T>& sp)
:_ptr(sp._ptr)
, _pcount(sp._pcount)
, _pmtx(sp._pmtx)
{
AddCount();
}
// sp1 = sp4
// sp1 = sp1;
// sp1 = sp2;
shared_ptr<T>& operator=(const shared_ptr<T>& sp)
{
if (_ptr != sp._ptr)
{
Release();
_ptr = sp._ptr;
_pcount = sp._pcount;
_pmtx = sp._pmtx;
AddCount();
}
return *this;
}
T& operator*()
{
return *_ptr;
}
T* operator->()
{
return _ptr;
}
T* get() const
{
return _ptr;
}
int use_count()
{
return *_pcount;
}
private:
T* _ptr;
int* _pcount;
mutex* _pmtx;
// 包装器
function<void(T*)> _del = [](T* ptr){
cout << "lambda delete:" << ptr << endl;
delete ptr;
};
};运行结果：
