智能指针

1、为什么要引入智能指针？

在c++中动态开辟的空间必须手动释放，在java中有垃圾回收机制，可
自动回收资源。智能指针是为了解决内存泄漏问题。

内存泄漏：动态开辟的空间，没有得到释放；

引发内存泄漏的原因：
1）new出来的空间没有delete；
2）执行流发生跳转，导致没有执行delete；

引发执行流跳转的原因：异常、return、break、continue、goto语句

内存泄漏的危害：导致内存资源减少，程序性能变低，导致程序崩溃

2、智能指针的实现思想

RAII（resource acquisition is initialization）资源分配即初始化，定
义一个类来封装资源的分配和释放，在构造函数完成资源的分配和初始化，在析构函数完成资源的清理，可以保证资源的正确初始化和释放。

注意：RAII不等价于智能指针，智能指针只是RAII思想的一种实现

3、智能指针的发展史

98及以前 ：
auto_ptr :通过管理权的转移，实现拷贝构造，带有严重缺陷的设计方案（可能会导致有的对象的指针悬空）尽量不要使用（c++向前兼容）

boost库（不是c++标准库） ：
scoped_ptr scoped_array （防拷贝的设计思想）
shared_ptr shared_array （引用计数的思想，可以进行拷贝构造，但实现比较复杂，存在循环引用的缺陷）
weak_ptr：解决循环引用问题，是一个弱指针

c++11 ：
unique_ptr （与scoped_ptr类似）、shared_ptr 、weak_ptr(参考boost库)

4、智能指针的实现

模拟实现auto_ptr

#define _CRT_SECURE_NO_WARNINGS 1
#pragma once
template<class T>
class AutoPtr
{
 public:
     AutoPtr(T* ptr)
         :_ptr(ptr)
     {
     }
     ~AutoPtr()
     {
         delete _ptr;
     }
     AutoPtr(const AutoPtr<T>& ap)
         :_ptr(ap._ptr)
     {
        ap._ptr=NULL;//管理权的转移
     }
     AutoPtr<T> operator=(const AutoPtr<T>& ap)
     {
         if(*this!=&ap)
         {
            if(_ptr)
            {
                delete _ptr;//只有一个对象可以获得管理权
            }
            _ptr=ap._ptr;
            ap._ptr=NULL;
         }
     }
     T& operator*()
     {
         return *_ptr;
     }
     T* operator->()
     {
         return _ptr;
     }
protected:
    T* _ptr;
};

总结：auto_ptr,是通过管理权的转移（即任何时刻只有一个指针来管理一块空间）来防止其进行拷贝构造；但这样有时会导致转移管理权的指针出现悬空（此时指针为空，若进行解引用操作就会出现错误）；尽量不要去使用auto_ptr（但它的存在是因为c++具有向前兼容的特性）

模拟实现 scoped_ptr

template<class T>
class ScopedPtr
{
public:
  //RAII思想
   ScopedPtr(T* ptr)
       :_ptr(ptr)
   {
   }
   ~ScopedPtr()
   {
       delete _ptr;
   }
   //像指针一样
   T& operator*()
    {
         return *_ptr;
    }
    T* operator->()
    {
         return _ptr;
    }
    ///拷贝
private:
   ScopedPtr(const ScopedPtr<T>& sp);//防拷贝
   ScopedPtr<T>& operator=(const ScopedPtr<T>& sp);

protected:
    T* _ptr;
};

总结：scoped_ptr是通过防拷贝（即只声明不定义，并且定义成私有）；解决拷贝构造问题；但它不能进行拷贝具有局限性，但在一些不需要拷贝的情况下比较适用，因为其效率比较高；

模拟实现shared_ptr

template<class T>
class SharedPtr
{
public:
  //RAII思想
  SharedPtr(T* ptr = NULL)
      :_ptr(ptr)
      ,_refcount(new int(1))
  {
  }
  ~SharedPtr()
   {
      if(--(*_refcount)==0)
      {
          delete _ptr;
          delete _refcount;
      }
   } 
   //像指针一样
   T& operator*()
    {
         return *_ptr;
    }
    T* operator->()
    {
         return _ptr;
    }
    //拷贝
    SharedPtr(const SharedPtr<T>& sp)
        :_ptr(sp._ptr)
        ,_refcount(sp._refcount)

    {
       ++(*_refcount);
    }
   SharedPtr<T>&  operator=(const SharedPtr<T>& sp)
   {
      if(_ptr!=sp._ptr)
      {
          if(--*_refcount==0)
          {
              delete _ptr;
              delete _refcount;
          }
         _ptr=sp._ptr;
         _refcount=sp._refcount;
        ++(*_refcount);
      }
      return *this;
   }
protected:
    T* _ptr;
    int* _refcount;
};

总结：shared_ptr,通过引用计数实现了拷贝问题；但其实现比较复杂，存在循环引用的缺陷；
循环引用问题：

struct ListNode
{
    SharedPtr<ListNode> _prev;
    SharedPtr<ListNode> _next;

    ~ListNode()
    {
        cout<<"~ListNode()"<<endl;
    }

};

void TestCycleRef()
{
    SharedPtr<ListNode> cur = new ListNode;
    SharedPtr<ListNode> next = new ListNode;

    cur->_next = next;
    next->_prev = cur;
}

那如何解决循环引用问题呢？此时引入了weak_ptr
模拟实现weak_ptr

template<class T>
class Weak_Ptr
{
public:
    WeakPtr()
        :_ptr(NULL)
    {}

    WeakPtr(const SharedPtr<T>& sp)
        :_ptr(sp._ptr)
    //由于sp._ptr是保护的，需要将WeakPtr定义为SharedPtr的友元类
    {}

    T& operator*()
    {
        return *_ptr;
    }

    T* operator->()
    {
        return _ptr;
    }

protected:
    T* _ptr;
};

在上述循环引用例子中

struct ListNode
{
    WeakPtr<ListNode> _prev;
    WeakPtr<ListNode> _next;

    ~ListNode()
    {
        cout<<"~ListNode()"<<endl;
    }

};

注意：这样便解决了shared_ptr的循环引用问题；但这种方式必须在程序员能预见会出现循环引用的情况下才能使用, 也可以是说这个仅仅是一种编译期的解决方案, 如果程序在运行过程中出 了循环引用, 还是会造成内存泄漏。