c++智能指针

一、内存泄漏

        什么是内存泄漏?

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

        内存泄漏的危害：

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

        内存泄漏的分类：

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

        如何解决内存泄漏

          内存泄漏非常常见，解决方案分为两种：1、事前预防型。如智能指针等。2、事后查错型。如泄漏检测工具。

二、智能指针

         RAII

         RAII（Resource Acquisition Is Initialization）是一种利用对象生命周期来控制程序资源.在对象构造时获取资源，接着控制对资源的访问使之在对象的生命周期内始终保持有效，最后在对象析构的时候释放资源.

        智能指针的概念

        所谓的智能指针本质就是一个类模板，它可以创建任意的类型的指针对象，当智能指针对象使用完后，对象就会自动调用析构函数去释放该指针所指向的空间
       

        智能指针的使用

        智能指针的使用和普通指针类似，可以使用“ * ”和“ -> ”去获得指向的对象，因此我们需要在类中重载这两个操作符。

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;
};
struct Date
{
 int _year;
 int _month;
 int _day;
};
int main()
{
 SmartPtr<int> sp1(new int);
 *sp1 = 10
 cout<<*sp1<<endl;
 SmartPtr<int> sparray(new Date);
 sparray->_year = 2018;
 sparray->_month = 1;
 sparray->_day = 1;
}

  三、c++库中的智能指针

        1.auto_ptr

                auto_ptr是c++98中提供的智能指针，该指针解决上诉的问题采取的措施是管理权转移的思想，就是原对象拷贝给新对象的时候，原对象就会设置为nullptr，此时只有新对象指向一块资源空间。

模拟实现简单auto_ptr：

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;
}

        如果auto_ptr调用拷贝构造函数或者赋值重载函数后，再去使用原来的对象的话，那么整个程序就会崩溃掉，所以很多公司禁止使用auto_ptr。

         2.unique_ptr

                unique_ptr是c++11版本库提供的智能指针，它将拷贝构造函数和赋值重载函数禁用了，因此不能拷贝和赋值。

模拟实现：

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:
 UniquePtr(UniquePtr<T> const &);
 UniquePtr & operator=(UniquePtr<T> const &);
 UniquePtr(UniquePtr<T> const &) = delete;
 UniquePtr & operator=(UniquePtr<T> const &) = delete;
 
private:
 T * _ptr;
};

         3.share_ptr

                C++11中开始提供更靠谱的并且支持拷贝的shared_ptr

int main()
{
 // shared_ptr通过引用计数支持智能指针对象的拷贝
 shared_ptr<Date> sp(new Date);
 shared_ptr<Date> copy(sp);
 cout << "ref count:" << sp.use_count() << endl;
 cout << "ref count:" << copy.use_count() << endl;
 return 0;
}

                shared_ptr的原理：是通过引用计数的方式来实现多个shared_ptr对象之间共享资源。。

                1. shared_ptr在其内部，给每个资源都维护了着一份计数，用来记录该份资源被几个对象共享。

                2. 在对象被销毁时(也就是析构函数调用)，就说明自己不使用该资源了，对象的引用计数减一。

                3. 如果引用计数是0，就说明自己是最后一个使用该资源的对象，必须释放该资源；

                4. 如果不是0，就说明除了自己还有其他对象在使用该份资源，不能释放该资源，否则其他对象就成野指 针了

模拟实现：

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();
 }
 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; 
};
int main()
{
 SharedPtr<int> sp1(new int(10));
 SharedPtr<int> sp2(sp1);
 *sp2 = 20;
 cout << sp1.UseCount() << endl;
 cout << sp2.UseCount() << endl;
 SharedPtr<int> sp3(new int(10));
 sp2 = sp3;
 cout << sp1.UseCount() << endl;
 cout << sp2.UseCount() << endl;
 cout << sp3.UseCount() << endl;
 sp1 = sp3;
 cout << sp1.UseCount() << endl;
 cout << sp2.UseCount() << endl;
 cout << sp3.UseCount() << endl;
 return 0;
}

        需要注意的是shared_ptr的线程安全分为两方面：

                1. 智能指针对象中引用计数是多个智能指针对象共享的，两个线程中智能指针的引用计数同时++或--，这 个操作不是原子的，引用计数原来是1，++了两次，可能还是2.这样引用计数就错乱了。会导致资源未 释放或者程序崩溃的问题。所以只能指针中引用计数++、--是需要加锁的，也就是说引用计数的操作是 线程安全的。

                2. 智能指针管理的对象存放在堆上，两个线程中同时去访问，会导致线程安全问题。