深入了解c++智能指针(RAII思想)

内存泄漏

内存泄漏概念

内存泄漏指因为疏忽或错误造成程序未能释放已经不再使用的内存的情况。
内存泄漏并不是指内存在物理上的消失，而是应用程序分配某段内存后，因为设计错误，失去了对该段内存的控制，因而造成了内存的浪费。

内存泄露危害

内存泄漏的危害：长期运行的程序出现内存泄漏，影响很大，如操作系统、后台服务等等，出现内存泄漏会导致响应越来越慢，最终卡死

内存泄漏分类

C/C++程序中一般我们关心两种方面的内存泄漏：

• 堆内存泄漏(Heap leak)
  堆内存指的是程序执行中依据须要分配通过malloc / calloc / realloc / new等从堆中分配的一块内存，用完后必须通过调用相应的 free或者delete 删掉。假设程序的设计错误导致这部分内存没有被释放，那么以后这部分空间将无法再被使用，就会产生Heap Leak。
• 系统资源泄漏
  指程序使用系统分配的资源，比方套接字、文件描述符、管道等没有使用对应的函数释放掉，导致系统资源的浪费，严重可导致系统效能减少，系统执行不稳定。

解决方式

解决方案分为两种：

• 1、事前预防型。如智能指针等。
• 2、事后查错型。如泄漏检测工具。

智能指针的使用及其原理

RAII

RAII（Resource Acquisition Is Initialization）是一种利用对象生命周期来控制程序资源（如内存、文件句柄、网络连接、互斥量等等）的简单技术。
RAII优势

• 不需要显式地释放资源。
• 采用这种方式，对象所需的资源在其生命期内始终保持有效。

智能指针的原理

智能指针就是基于RAII思想所开发一个特殊指针。
首先智能指针是一个类，类的模板就是智能指针所管理的类型。通过重载* ->等操作，使得这个类具有像指针一样的行为。并且在其生命周期结束的时候会自己调用析构函数释放资源。我们就将这个特殊的指针叫做智能指针。

管理权转移版本 auto_ptr

// 模拟实现一份简答的AutoPtr,了解原理
template<class T>
class AutoPtr
{
public:
 AutoPtr(T* ptr = NULL)
 : _ptr(ptr)
 {}
 
 ~AutoPtr()
 {
 if(_ptr)
 delete _ptr;
 }
 
 // 一旦发生拷贝，就将ap中资源转移到当前对象中，然后另ap与其所管理资源断开联系，
 // 这样就解决了一块空间被多个对象使用而造成程序奔溃问题
 AutoPtr(AutoPtr<T>& ap)
 : _ptr(ap._ptr)
 {
 ap._ptr = NULL;
 }
 
 AutoPtr<T>& operator=(AutoPtr<T>& ap)
 {
 // 检测是否为自己给自己赋值
 if(this != &ap)
 {
 // 释放当前对象中资源
 if(_ptr)
 delete _ptr;
 
 // 转移ap中资源到当前对象中
 _ptr = ap._ptr;
 ap._ptr = NULL;
  }
 
 return *this;
 }
 
 T& operator*() {return *_ptr;}
 T* operator->() { return _ptr;}
private:
 T* _ptr;
};
int main()
{
 AutoPtr<Date> ap(new Date);
 
 // 现在再从实现原理层来分析会发现，这里拷贝后把ap对象的指针赋空了，导致ap对象悬空
 // 通过ap对象访问资源时就会出现问题。
 AutoPtr<Date> copy(ap);
 ap->_year = 2018;
 return 0; }

缺陷：拷贝 赋值时候，需要谨慎使用

防拷贝版本 unique_ptr

// 模拟实现一份简答的UniquePtr,了解原理
template<class T>
class UniquePtr
{
public:
 UniquePtr(T * ptr = nullptr) 
 : _ptr(ptr)
 {}
 ~UniquePtr() 
 {
 if(_ptr)
 delete _ptr;
 }
 T& operator*() {return *_ptr;}
 T* operator->() {return _ptr;}
 
private:
 // C++98防拷贝的方式：只声明不实现+声明成私有
 UniquePtr(UniquePtr<T> const &);
 UniquePtr & operator=(UniquePtr<T> const &);
 
 // C++11防拷贝的方式：delete
 UniquePtr(UniquePtr<T> const &) = delete;
 UniquePtr & operator=(UniquePtr<T> const &) = delete;
 
private:
 T * _ptr;
};

禁止了拷贝和赋值操作

引用计数版本 shared_ptr

template <class T>
class SharedPtr
{
public:
 SharedPtr(T* ptr = nullptr)
 : _ptr(ptr)
 , _pRefCount(new int(1))
 , _pMutex(new mutex)
 {}
 ~SharedPtr() {Release();}
 SharedPtr(const SharedPtr<T>& sp)
 : _ptr(sp._ptr)
 , _pRefCount(sp._pRefCount)
 , _pMutex(sp._pMutex)
 {
 AddRefCount();
 }
 // sp1 = sp2
 SharedPtr<T>& operator=(const SharedPtr<T>& sp)
 {
 //if (this != &sp)
 if (_ptr != sp._ptr)
 {
 // 释放管理的旧资源
 Release();
 // 共享管理新对象的资源，并增加引用计数
 _ptr = sp._ptr;
 _pRefCount = sp._pRefCount;
 _pMutex = sp._pMutex;
 
 AddRefCount();
 }
 return *this;
 }
 T& operator*() {return *_ptr;}
 T* operator->() {return _ptr;}
 int UseCount() {return *_pRefCount;}
 T* Get() { return _ptr; }
 void AddRefCount()
 {
 // 加锁或者使用加1的原子操作
 _pMutex->lock();
 ++(*_pRefCount);
 _pMutex->unlock();
 }
private:
 void Release()
 {
 bool deleteflag = false;
 
 // 引用计数减1，如果减到0，则释放资源
 _pMutex.lock();
 if (--(*_pRefCount) == 0)
 {
 delete _ptr;
 delete _pRefCount;
 deleteflag = true;
 }
 _pMutex.unlock();
 
 if(deleteflag == true)
 delete _pMutex;
 }
private:
 int* _pRefCount; // 引用计数
 T* _ptr; // 指向管理资源的指针 
 mutex* _pMutex; // 互斥锁
};

采用计数方式判断资源是否需要释放，线程安全，当出现循环引用时无法释放资源

其他

防止循环引用 weak_ptr
仅针对于循环引用的特殊情况，针对于强智能指针(shared_ptr )相互引用会出现内存无法释放的情况，加入弱智能指针(weak_ptr)。
delete[]
普通智能指针内部是一个delete 针对的是new出来的对象，当我们需要释放new[]时候，我们就可以自己写一个仿函数进行操作
RAII思想的其他应用：守卫锁。