目录
- 为什么需要智能指针？
- 内存泄露
- 智能指针的使用及原理
- c++11和boost中智能指针的关系
- RAII扩展学习
1. 为什么需要智能指针？
下面我们先分析一下下面这段程序有没有什么内存方面的问题？
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;
}
上面的程序抛异常后，会导致资源没有释放
2. 内存泄露
2.1 什么是内存泄露，危害
内存泄露指因为疏忽或错误造成程序未能释放已经不再使用的内存的情况，并不是指内存在物理上消失，而是应用程序分配某段内存后，因为设计错误，失去了对这段内存的控制，因而造成了内存的浪费
危害：长期运行的程序出现内存泄露，影响很大，如操作系统、后台服务等等，出现内存泄露导致响应越来越慢，最终卡死
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;
}
2.2 内存泄露分类
c/c++一般关心两方面的泄露
-
堆内存泄露(Heap Leak)
堆内存指程序执行中依据需要分配过malloc/calloc/realloc/new等从堆中分配的一块内存，用完后必须调用对应的free或者delete删掉。假设程序的设计错误导致这部分内存没有被释放，那么以后这部分空间将无法再被使用，会产生Heap Leak -
系统资源泄露
指程序使用系统分配的资源，比如套接字、文件描述符、管道等没有使用对应的函数释放掉，导致系统资源的浪费，严重可导致系统效能减少，系统执行不稳定
2.3 如何检测内存泄露（了解）
在linux下：linux下几款内存泄漏检测工具
在windows下：VLD工具说明
其他工具：内存泄漏工具比较
2.4 如何避免内存泄露
1.工程前期良好的设计规范，养成良好的编码规范，申请的内存空间记着匹配的去释放。ps：这个理想状态，但是如果碰上异常时，就注意释放了，还是可能会出现问题，需要智能指针来管理才有保证
2.采用RAII思想或者智能指针来管理
3.有些公司内部规范使用内部实现的私有内存管理库，这套库自带内存泄露检测的功能选项
4.出问题了使用内存泄露工具检测。ps：不过很多工具都不够靠谱，收费昂贵
总结一下：
内存泄露工具非常常见，解决方案分为两种：1.事前预防型，如智能指针等 2.事后查错型，如泄露检测工具
3. 智能指针的使用及原理
3.1 RAII
RAII（Resource Acquisition Is Initialization）是一种利用对象生命周期来控制程序资源（内存、文件句柄、网络连接、互斥量等等）的简单技术
在对象构造时获取资源，接着控制对资源的访问使之在对象的生命周期内始终保持有效，最后在对象析构的时候释放资源。借此，我们实际上把管理一份资源的责任托管给了一个对象，有两个好处：
- 不需要显式的释放资源
- 对象所需的资源在其生命周期始终有效
template <class T>
class AutoPtr
{
public:
AutoPtr(T* ptr)
:_ptr(ptr)
{}
~AutoPtr()
{
if (_ptr)
{
std::cout << "delete ptr" << std::endl;
delete _ptr;
}
}
private:
T* _ptr;
};
3.2 智能指针的原理
上面的autoptr还不鞥称为智能指针，因为还不具有指针的行为。指针可以解引用，可以通过->访问。所以还需要重载这些
T& operator*()
{
return *_ptr;
}
T* operator->()
{
return _ptr;
}
总结一下智能指针的原理
1.RAII特性
2.重载*和->，具有指针一样的行为
这个智能指针虽然可以自动释放资源，但当用一个智能指针拷贝另一个，就会崩溃，第二次释放是野指针。看看库的指针解决这个问题是如何发展的
SharedPtr<int> p = new int(5);
SharedPtr<int> p2(p);
SharedPtr<int> p3 = new int(3);
p3 = p;
3.3 std::auto_ptr
std::auto_ptr文档
c++98版本的库中提供了auto_ptr的智能指针，下面展示auto_ptr的使用及问题
auto_ptr的实现原理：管理权转移的思想，下面简化模拟实现了一份bit::auto_ptr来了解原理
// C++98 管理权转移 auto_ptr
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 = NULL;
}
return *this;
}
~auto_ptr()
{
if (_ptr)
{
std::cout << "delete:" << _ptr << std::endl;
delete _ptr;
}
}
// 像指针一样使用
T& operator*()
{
return *_ptr;
}
T* operator->()
{
return _ptr;
}
private:
T* _ptr;
};
// 结论：auto_ptr是一个失败设计，很多公司明确要求不能使用auto_ptr
//int main()
//{
// std::auto_ptr<int> sp1(new int);
// std::auto_ptr<int> sp2(sp1); // 管理权转移
//
// // sp1悬空
// *sp2 = 10;
// cout << *sp2 << endl;
// cout << *sp1 << endl;
// return 0;
//}
这种会将之前的指针悬空，不熟悉机制的人访问会出错
3.4 std::unique_ptr
c++11提供了更靠谱的unique_ptr
unique_ptr文档
简单粗暴的防止拷贝
// C++11库才更新智能指针实现
// C++11出来之前，boost搞除了更好用的scoped_ptr/shared_ptr/weak_ptr
// C++11将boost库中智能指针精华部分吸收了过来
// C++11->unique_ptr/shared_ptr/weak_ptr
// unique_ptr/scoped_ptr
// 原理：简单粗暴 -- 防拷贝
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;
}
unique_ptr(const unique_ptr<T>& sp) = delete;
unique_ptr<T>& operator=(const unique_ptr<T>& sp) = delete;
private:
T* _ptr;
};
3.5 std::shared_ptr
c++11开始提供更靠谱的并且支持拷贝的shared_ptr
std::shared_ptr文档
shared_ptr的原理：是通过引用计数的方式实现多个shared_ptr对象之间共享资源。例如：老师下课前会让最后走的学生把门锁上
1.shared_ptr在其内部，给每个资源都维护了一个计数，记录该资源被几个对象共享
2.对象拷贝和赋值时，增加一个对象访问资源，计数加一。在对下被销毁时(也就是析构函数调用)，说明自己不使用该资源了，对象的引用计数减一
3.如果引用计数是0，说明自己是最后一个使用该资源的对象，必须释放该资源
4.如果不是0，说明除了自己海域其他对象在使用该资源，不能释放该资源，否则其他对象就成野指针了
计数要保证管理同一个资源的指针访问相同的引用计数，得跟着资源走。int显然不行，static会导致所有对象都访问一份，不同资源的指针需要有自己的计数。所以用指针保存计数
template<class T>
class shared_ptr
{
public:
shared_ptr(T* ptr = nullptr)
:_ptr(ptr)
, _pRefCount(new int(1))
, _pmtx(new mutex)
{}
shared_ptr(const shared_ptr<T>& sp)
:_ptr(sp._ptr)
, _pRefCount(sp._pRefCount)
, _pmtx(sp._pmtx)
{
AddRef();
}
void Release()
{
_pmtx->lock();
bool flag = false;
if (--(*_pRefCount) == 0 && _ptr)
{
cout << "delete:" << _ptr << endl;
delete _ptr;
delete _pRefCount;
flag = true;
}
_pmtx->unlock();
if (flag == true)
{
delete _pmtx;
}
}
void AddRef()
{
_pmtx->lock();
++(*_pRefCount);
_pmtx->unlock();
}
shared_ptr<T>& operator=(const shared_ptr<T>& sp)
{
//if (this != &sp)
if (_ptr != sp._ptr)
{
Release();
_ptr = sp._ptr;
_pRefCount = sp._pRefCount;
_pmtx = sp._pmtx;
AddRef();
}
return *this;
}
int use_count()
{
return *_pRefCount;
}
~shared_ptr()
{
Release();
}
// 像指针一样使用
T& operator*()
{
return *_ptr;
}
T* operator->()
{
return _ptr;
}
T* get() const
{
return _ptr;
}
private:
T* _ptr;
int* _pRefCount;
mutex* _pmtx;
};
std::shared_ptr的线程安全问题
在多线程章节说明
循环引用问题
上面的基本完美，但还有循环引用的问题
struct ListNode
{
int _data;
shared_ptr<ListNode> _prev;
shared_ptr<ListNode> _next;
~ListNode(){ cout << "~ListNode()" << endl; }
};
shared_ptr<ListNode> node1(new ListNode);
shared_ptr<ListNode> node2(new ListNode);
cout << node1.use_count() << endl;
cout << node2.use_count() << endl;
node1->_next = node2;
node2->_prev = node1;
}
cout << node1.use_count() << endl;
cout << node2.use_count() << endl;
分析：
1.node1和node2两个智能指针对象指向两个节点，引用计数变为1，不需要手动deelte
2.node1的_next指向node2，node2的_prev指向node1，引用计数变为2
3.node1和node2析构，引用计数减到1，但是_next还指向下一个节点，但是_prev还指向上一个节点
4.也就是说_next析构了，node2就释放了
5.也就是说_prev析构了，node1就释放了
6.但是_next属于node的成员，node1释放了，node1释放了，_next才会析构，而node1由_prev管理，_prev属于node2成员，这就是循环引用，谁也不会释放
解决方法就是把节点的两个指针换成weak_ptr，原理：node1->_next = node2，这两个步骤是不会增加node1和node2的引用计数
template <class T>
class WeakPtr
{
public:
WeakPtr()
:_ptr(nullptr)
{}
WeakPtr(const SharedPtr<T>& sp)
:_ptr(sp.get())
{}
WeakPtr<T>& operator=(const SharedPtr<T>& sp)
{
_ptr = sp.get();
return *this;
}
// 像指针一样使用
T& operator*()
{
return *_ptr;
}
T* operator->()
{
return _ptr;
}
private:
T* _ptr;
};
如果不是new出来的是一个数组，[]这种就会出问题。可以设计一个删除器来解决，构造的时候传入一个调用对象，释放的时候调用
template <class D>
SharedPtr(T* ptr, D del)
: _ptr(ptr),
_pcount(new int(1)),
_del(del)
{
}
void Release()
{
if (--(*_pcount) == 0)
{
//std::cout << "delete ptr" << std::endl;
_del(_ptr);
}
}
std::function<void(T*)> _del = [](T* ptr) {delete ptr; };
SharedPtr<int> p(new int[5], [](int* ptr) {delete[] ptr; });
4. c++11和boost中智能指针的关系
Boost库是为C++语言标准库提供扩展的一些C++程序库的总称，由Boost社区组织开发、维护。Boost库可以与C++标准库完美共同工作，并且为其提供扩展功能。
1.c++98中产生了第一个智能指针auto_ptr
2.c++boost给出了更实用的scoped_ptr和shared_ptr和weak_ptr
3.c++TR1，引入了shared_ptr等。不过注意的是TR1并不是标准版
4.c++11，引入了unique_ptr和shraed_ptr和weak_ptr。需要注意的是unique_ptr对应boost的scoped_ptr。并且这些智能指针的实现原理是参考boost实现的
