c++：简单分析智能指针

为什么提出智能指针？
首先，我们要知道c++中的动态内存管理是通过一对运算符来控制的：
new：在动态内存中为对象分配空间并返回一个指向该对象的指针，我们并可以选择对对象初始化。
delete：接受一个动态对象的指针，销毁该对象，并释放与之关联的内存。
可是，我们有时候会忘记释放内存，或者是程序未必会执行到我们释放的那一步，从而造成内存泄漏。有时在尚有指针引用内存的情况下我们就释放了它，在这种情况下就会产生引用非法内存的指针。

int* p = new int[10];FILE *pfile = fopen("smart_pointer.cpp", "r");if (pfile == NULL){    return;      //当文件不存在时，就会导致内存泄露}if (p){    delete[]p;    p = NULL;}

这时候有人就提出了RAII思想来解决这个问题（RALL机制便是通过利用对象的自动销毁，使得资源也具有了生命周期，有了自动销毁的功能。）从而实现智能指针。
事实上智能指针就是智能/自动化地管理指针所指向的动态资源的释放。而所谓的智能主要就是利用类的默认成员函数中的析构函数的特性。
智能指针的发展历史
c++98：

auto_ptr //自动指针这是一种带有缺陷的设计。管理权转移，最后一个指向该空间的指针带有管理权。

boost库：

scoped_ptr //守卫指针；防拷贝，简单粗暴shared_ptr//共享指针； 引用计数，更实用更复杂waek_ptrscoped_arrayshared_array

c++11：

   unique_ptrshared_ptrweak_ptr

有问题就要解决，完善就是一个发展的过程：

接下来，由我来一一解析各个智能指针的功能！
auto_ptr

#include<iostream>using namespace std;template<class T>class Auto_ptr{public:    Auto_ptr(T* ptr)        :_ptr(ptr)    {}    ~Auto_ptr()    {        cout<<"释放啦"<<endl;        delete _ptr;    }    Auto_ptr(Auto_ptr<T>& ap)        :_ptr(ap._ptr)    {        ap._ptr=NULL;    }    Auto_ptr<T>& operator=(Auto_ptr<T>& ap)    {        if(_ptr!=ap._ptr)        {            if(_ptr)            {                delete _ptr;            }            _ptr=ap._ptr;            ap._ptr=NULL;        }        return *this;    }    T& operator*()    {        return *_ptr;    }    T* operator->()    {        return _ptr;    }private:    T* _ptr;};int main(){    Auto_ptr<int>ap1(new int(10));    Auto_ptr<int>ap2(ap1);    cout<<*ap1<<endl;    return 0;}

然而，当我们调用旧指针时程序就会崩溃，这正是由于新指针*ap2争夺了旧指针的空间，导致*ap1无家可归。

这正是auto_ptr的思想核心——管理权转移，当有新的指针进行拷贝构造或者赋值时，就会剥夺旧的指针的管理权，当我们访问旧指针时，就会发生错误，这即是它的缺陷所在。

scoped_ptr
针对auto_ptr里的问题，scoped_ptr索性直接就不让用户在使用的时候进行拷贝构造或者赋值，也就避免了之后错误的发生。
要实现防拷贝和赋值【1】只声明不实现（类外实现）【2】将声明放入私有中，防止定义。

template<class T>  class Scoped_ptr  {  public:      Scoped_ptr()      {}      Auto_ptr(T* ptr)          :_ptr(ptr)      {}      T* operator->()      {          return _ptr;      }      T& operator*()      {          return *_ptr;      }      ~Auto_ptr()      {          cout << "释放啦" << endl;          delete _ptr;      }  protected:      Scoped_ptr(Scoped_ptr<T>& s);      Scoped_ptr<T> operator=(Scoped_ptr<T>& s);  protected:      T* _ptr;  };  

对于上面的改进，我们不使用拷贝功能的智能指针时还好，一旦需要Scoped_ptr便不能满足要求，因此，我们再引入一个智能指针，专门用于处理复制，参数传递的情况。
这便是如下的shared智能指针。

shared_ptr
当我们真正需要完成指针拷贝或者赋值功能时，可以重新开辟空间用于存放引用计数，让两个指针指向同一片空间，引入引用计数来控制拷贝和析构。

template <class T>class Shared_ptr{public:    Shared_ptr(T* sp)        :_ptr(sp)        ,_count(new int(1)) //在初始化时置1    {}    ~Shared_ptr()    {        cout << "释放啦" << endl;        Release();    }    Shared_ptr(Shared_ptr<T>& sp)        :_ptr(sp._ptr)        ,_count(sp._count)    {        (*_count)++;    }    Shared_ptr<T>& operator= (Shared_ptr<T>& sp)    {        if (_ptr != sp._ptr)        {            Release();            _ptr = sp._ptr;            _count = sp._count;            (*_count)++;        }        return *this;    }    T& operator*()    {        return *_ptr;    }    T* operator->()    {        return _ptr;    }    void Release()    {        if (--(*_count) == 0)        {            delete _ptr;            delete _count;            _ptr = NULL;            _count = NULL;        }    }    int GetCount()//获取count    {        return *_count;    }    T* GetPtr() const//获取指针    {        return _ptr;    }protected:    T* _ptr;    int* _count;};int main(){    Shared_ptr<int>sp1(new int(1));    Shared_ptr<int>sp2(sp1);    *sp2=20;    cout<<*sp1<<endl;    cout<<sp1.GetCount()<<endl;    cout<<sp2.GetCount()<<endl;}

由测试结果可知，引用计数确实解决了拷贝的问题，但同时又存在新的缺陷——循环引用问题。

这时候循环引用问题就出现了
（1）左侧的left节点想要释放须让内部count=0,由于此时right节点的_prev也指向该空间导致count=2，所以只有当右侧的_prev节点释放了，才能使指向左侧节点的指针只有left一个，从而-count=0完成节点的释放。
（2）同样右侧节点的_prev想要释放，须等右侧节点释放，右侧节点的释放依赖于左侧的_next节点，左侧的_next节点的释放又依赖于left节点。此时又回到（1）处的逻辑，如此往重复循环。
这时候我们又引入了新的智能指针waek_ptr。

waek_ptr
waek_ptr更像是shared_ptr的一个助手，因为waek_ptr不会增加shared_ptr所指向空间的引用计数，我们只需要把节点的_next和_prev指针都改为waek_ptr，就可以避免循环引用问题。

总结：
当我们熟悉了各个智能指针的功能，便可以灵活的使用boost库所包含的各个函数。

(1)在boost库中不要使用auto_ptr智能指针，因为它不符合c++的编程思想、。
(2)用智能指针来管理空间时，就尽量不出现malloc（new）或free（delete）;
(3)不需要实现拷贝赋值功能使用 scoped_ptr。
(4)对象需共享的情况下使用shared_ptr。
(5)在需要访问共享对象又不改变引用计数的情况下使用weak_ptr。