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_ptr
scoped_array
shared_array

c++11：

   unique_ptr
shared_ptr
weak_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。