在C++之异常中我们了解了异常有关的问题。提到了异常安全的问题。本篇博客就是学习解决异常安全问题的方法------智能指针。
文章目录
一、内存泄漏（复习）
- 详情请见C++之动态内存管理。
1.内存泄漏的定义
- 内存泄漏指的是因为疏忽或者错误造成程序未能释放已经不再使用的内存的情况。内存泄漏并不是指内存在物理上的消失，而是应用程序分配某段内存后，因为错误，失去了对该段内存的控制，因而造成了内存的浪费。
2.内存泄漏的危害
- 长期运行的程序出现内存泄漏，影响会很大，如操作系统、后台服务等等。出现内存泄漏会导致设备响应越来越慢，最终卡死。
3.内存泄漏的分类
- 堆内存泄漏
- 系统资源泄漏
二、RAII
void test()
{
int* p1 = new int[10];
int* p2 = new int[20];
int* p3 = new int[30];
try
{
func();//func函数可能会抛异常
}
catch (...)
{
delete[] p1;
delete[] p2;
delete[] p3;
}
delete[] p1;
delete[] p2;
delete[] p3;
}
- 上述代码中如果func函数抛异常便可以使用中间抛异常再捕获的方法防止p1、p2、p3没有释放资源而造成的内存泄漏的问题。
- 但是如果是new int[]抛出异常，则用中间抛异常再捕获的方法避免造成内存泄漏的问题会比较麻烦。
1.RAII基本介绍
- RAII即获取资源后立即初始化，是智能指针的核心原理。
- RAII是一种利用对象生命周期来控制程序资源（如内存、文件句柄、网络连接、互斥量等）的简单技术。
- RAII是在对象构造时获取资源，接着控制对资源的访问，使之在对象的生命周期内始终保持有效，最后在对象析构的时候释放资源。实际上是把管理一个资源的责任托付给一个对象，这样就可以不需要显式的释放资源、而且对象所需的资源在其生命周期内都有效。
2.SmartPtr的方法解决上述代码问题
#include <iostream>
#include <memory>
using namespace std;
template<class T>
class SmartPtr
{
public:
SmartPtr(T* ptr)
:_ptr(ptr)
{}
~SmartPtr()
{
delete _ptr;
}
private:
T* _ptr;
};
void test()
{
SmartPtr<int> sp1(new int[10]);
SmartPtr<int> sp2(new int[20]);
SmartPtr<int> sp3(new int[30]);
throw out_of_range(“访问出错”);
}
int main()
{
try
{
test();
}
catch (exception e)
{
cout << e.what() << endl;
}
catch (...)
{
cout << "Unkown Exception" << endl;
}
return 0;
}
- 上述代码中无论test()函数会正常运行还是异常运行，都不会出现sp1、sp2、sp3没有释放造成内存泄漏的问题。因为只要出了test()作用域，都会自动调用对象的析构函数释放sp1、sp2和sp3。
三、智能指针的版本及发展历史
- 智能指针都会满足RAII管理资源和像指针一样去使用。
1.C++98------auto_ptr
#include <iostream>
#include <memory>
using namespace std;
namespace sheena
{
template <class T>
class auto_ptr
{
public:
//RAII
auto_ptr(T* ptr)
:_ptr(ptr)
{}
~auto_ptr()
{
if(_ptr)
delete _ptr;
}
//像指针一样
T& operator*()
{
return *_ptr;
}
T* operator->()
{
return _ptr;
}
/*
智能指针的拷贝构造就是浅拷贝，为了解决一块空间可能被
释放多次的问题，只要将原来的指针置为空（nullptr）即可
*/
auto_ptr(const auto_ptr<T>& ap)
:_ptr(ap._ptr)
{
ap._ptr = nullptr;
}
auto_ptr<T>& operator=(const auto_ptr<T>& ap)
{
if (this != &ap)
{
if (_ptr)
delete _ptr;
_ptr = ap._ptr;
ap._ptr = nullptr;
}
return *this;
}
private:
T* _ptr;
};
}
- 但是auto_ptr有一个问题，就是会悬空，如下所示
namespace sheena
{
void test()
{
auto_ptr<int> ap1(new int);
auto_ptr<int> ap2(ap1);
*ap1 = 100;
}
}
int main()
{
sheena::test();
return 0;
}
- 因为ap1拷贝构造ap2之后，ap1就会被置空（nullptr），所以在访问*ap1就会出错。
2.C++11------unique_ptr
#include <iostream>
#include <memory>
using namespace std;
namespace sheena
{
template <class T>
class unique_ptr
{
public:
//RAII
unique_ptr(T* ptr)
:_ptr(ptr)
{}
~unique_ptr()
{
if (_ptr)
delete _ptr;
}
//像指针一样去使用
T& operator*()
{
return *_ptr;
}
T* operator->()
{
return _ptr;
}
//该智能指针拷贝构造简单粗暴：直接不让拷贝构造和赋值
unique_ptr(const unique_ptr<T>&) = delete;
unique_ptr<T>& operator=(const unique_ptr<T>&) = delete;
private:
T* _ptr;
};
}
3.C++11------shared_ptr
（1）
#include <iostream>
#include <memory>
using namespace std;
namespace sheena
{
template <class T>
class shared_ptr
{
public:
//RAII
shared_ptr(T* ptr)
:_ptr(ptr)
,_pCount(new int(1))
{}
~shared_ptr()
{
if (--(*_pCount) == 0)
{
delete _pCount;
if (_ptr)
delete _ptr;
}
}
//像指针一样去使用
T& operator*()
{
return *_ptr;
}
T* operator->()
{
return _ptr;
}
/*
在堆上，第一个管理资源的智能指针对象，为资源
创建一个引用计数，后面拷贝的智能指针对象一起
管理，也指向这个引用计数，且++引用计数就可以
*/
/*
如果引用计数是1，则表示自己是最后一个管理的对象，
那么释放。如果不是1就--引用计数。
*/
shared_ptr(const shared_ptr<T>& sp)
:_ptr(sp._ptr)
, _pCount(sp._pCount)
{
++(*_pCount);
}
shared_ptr<T>& operator=(const shared_ptr<T>& sp)
{
if (this != &sp && _ptr != sp._ptr)
{
if (--(*_pCount) == 0)
{
delete _pCount;
if (_ptr)
delete _ptr;
}
_ptr = sp._ptr;
_pCount = sp._pCount;
++(*_pCount);
}
return *this;
}
private:
T* _ptr;
int* _pCount;
};
}
（2）实现线程安全的shared_ptr
- 在++引用计数和–引用计数的时候加锁就可以实现线程安全
#include <iostream>
#include <memory>
#include <mutex>
using namespace std;
namespace sheena
{
template <class T>
class shared_ptr
{
public:
//RAII
shared_ptr(const T& ptr)
:_ptr(ptr)
,_pCount(new int(1))
,_pMutex(new mutex)
{}
~shared_ptr()
{
ReleaseRef();
}
//像指针一样去使用
T& operator*()
{
return *_ptr;
}
T* operator->()
{
return _ptr;
}
//加锁之后的引用计数的拷贝构造和赋值
shared_ptr(const shared_ptr<T>& sp)
:_ptr(sp._ptr)
,_pCount(sp._pCount)
,_pMutex(sp._pMutex)
{
AddRef();
}
shared_ptr<T>& operator=(const shared_ptr<T>& sp)
{
if (this != &sp && _ptr != sp._ptr)
{
ReleaseRef();
_ptr = sp._ptr;
_pCount = sp._pCount;
_pMutex = sp._pMutex;
AddRef();
}
return *this;
}
//方便实现线程安全
void AddRef()
{
_pMutex->lock();
++_pCount;
_pMutex->unlock();
}
void ReleaseRef()
{
_pMutex->lock();
bool flag = false;
if (--(*_pCount) == 0)
{
delete _pCount;
delete _ptr;
flag = true;
}
_pMutex->unlock();
if (flag == true)
delete _pMutex;
}
private:
T* _ptr;
int* _pCount;
mutex _pMutex;
};
}
4.C++11------weak_ptr（解决循环引用）
（1）循环引用
#include <iostream>
#include <memory>
#include <mutex>
using namespace std;
struct Node
{
shared_ptr<Node> _prev;
shared_ptr<Node> _next;
int val;
~Node()
{
cout << "~Node()" << endl;
}
};
void cycleRef()
{
shared_ptr<Node> n1(new Node);
shared_ptr<Node> n2(new Node);
//这两句代码产生了循环引用
n1->_next = n2;
n2->_prev = n1;
}
int main()
{
cycleRef();
return 0;
}
- 由上述代码的结果可以看出，n1和n2都没有释放。原因是产生了循环引用。
- n1和n2两个智能指针对象指向两个结点，引用计数变成1。
- n1的_next指向n2，n2的_prev指向n1，引用计数变为2。
- n1和n2析构，引用计数减到1，但是_next还指向下一个节点，_prev还指向上一个节点。
- 如果n1._next析构了，n2就释放了。
- 如果n2._prev析构了，n1就释放了。
- 但是n1._next属于n1成员，n1释放了，n1._next才会析构，而n1由n2._prev管理，n2._prev属于n2成员，故叫循环引用，谁也不会释放。
（2）解决方案------weak_ptr
#include <iostream>
#include <memory>
using namespace std;
struct Node
{
weak_ptr<Node> _prev;
weak_ptr<Node> _next;
int val;
~Node()
{
cout << "~Node()" << endl;
}
};
void cycleRef()
{
shared_ptr<Node> n1(new Node);
shared_ptr<Node> n2(new Node);
n1->_next = n2;
n2->_prev = n1;
}
int main()
{
cycleRef();
return 0;
}
- weak_ptr可以像指针一样去使用，但它不会增加shared_ptr的引用计数，不参与对资源的管理，可以访问资源，不参于对资源释放的管理。
四、智能指针的总结
| 智能指针 | 产生 | 介绍 |
|---|---|---|
| auto_ptr | C++98 | 管理权转移，导致悬空。带有缺陷的设计。 |
| scoped_ptr / scoped_array | boost中 | 防止拷贝构造、赋值，在无需拷贝构造、赋值的情况下，建议使用。 |
| shared_ptr / weak_ptr | boost中 | 引用计数，支持拷贝，拷贝时增加计数，析构时减少计数。当计数减到0时，最后一个对象释放资源。 |
| unique_ptr | C++11 | 防止拷贝构造、赋值，在无需拷贝构造、赋值情况下，建议使用。 |
| shared_ptr/weak_ptr | C++11 | 引用计数，支持拷贝，拷贝时增加计数，析构时减少计数。当计数减到0时，最后一个对象释放资源。 |
759
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
