一、认识智能指针

c++的内存管理是让很多人头疼的事，当我们写一个new语句时，有时候我们不能避免程序还未执行到delete时就跳转了或者在函数中没有执行到最后的delete语句就返回了。
如果我们不在每一个可能跳转或者返回的语句前释放资源，就会造成内存泄露。使用智能指针可以很大程度上的避免这个问题。

二、智能指针的原理

把管理一份资源的责任托管给了一个对象
在对象构造时获取资源，最后在对象析构的时候释放资源。

举一个例子：

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

int main()
{
 SmartPtr<int> sp1(new int);
 *sp1 = 10
 cout<<*sp1<<endl;
}

这种做法有两大好处：

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

几种智能指针

auto_ptr（C++98）

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（C++11）

unique_ptr的实现原理：简单粗暴的防拷贝

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（C++11）

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

shared_ptr在其内部，给每个资源都维护了着一份计数，用来记录该份资源被几个对象共享。
在对象被销毁时(也就是析构函数调用)，就说明自己不使用该资源了，对象的引用计数减一。
如果引用计数是0，就说明自己是最后一个使用该资源的对象，必须释放该资源。
如果不是0，就说明除了自己还有其他对象在使用该份资源，不能释放该资源，否则其他对象就成野指针了

#include <thread>
#include <mutex>
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; // 互斥锁
};

std::shared_ptr的线程安全问题

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