智能指针

为什么要有智能指针？

C++引入了异常处理，就带来了另一个问题。看下面一段代码。

void Func()
{
    int *p = new int;
    FILE* pf = fopen("test.txt","r");

    //处理函数

    dosomething()
    {
        throw exception("异常");//抛出异常
    }
    delete p;
    fclose(pf);
}

int main(void)
{
    try
    {
        Func();
    }
    catch (exception e)//捕获异常
    {
        cout<<e.what()<<endl;
    }
    return 0;
}

代码没有内容没有实际意义，但是在上面代码中很明显，有内存泄漏和文件描述符未关闭。具体原因就是因为在程序中抛出了异常。当然我们可以在抛出异常前关闭文件描述符和释放内存等等，但是如果每次都这样处理，会造成程序冗长丑陋。
于是我们就有了一项新技术，RAII技术。

RAII技术

　　RAII（Resource Acquisition Is Initialization）是一种利用对象生命周期来控制程序资源（如内存、文件句柄、网络连接、互斥量等等）的简单技术。
　　RAII 的一般做法是这样的：在对象构造时获取资源，接着控制对资源的访问使之在对象的生命周期内始终保持有效，最后在对象析构的时候释放资源。借此，我们实际上把管理一份资源的责任托管给了一个对象。
这种做法有两大好处：

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

智能指针

智能指针：即RAII最具代表的实现，使用智能指针，可以实现自动的内存管理，再也不需要担心忘记delete造成的内存泄漏。毫不夸张的来讲，有了智能指针，代码中几乎不需要再出现delete了。
智能指针分为auto_ptr、scoped_ptr、scoped_array、shared_ptr、shared_array

Auto_ptr

template<class T>
class Auto_ptr
{
public:
    Auto_ptr( T* ptr)
        :_ptr(ptr)
    {}
    ~Auto_ptr()
    {
        delete _ptr;
    }
protected:
    T* _ptr;
};

void Func()
{
    Auto_ptr<int> p(new int); //开辟了空间交给Auto_ptr类来管理空间。

    //处理函数

    throw exception("异常");
}
int main(void)
{
    try
    {
        Func();
    }
    catch (exception e)
    {
        cout<<e.what()<<endl;
    }

    return 0;
}

这样不管我们如何抛异常，程序都会自动释放内存，再也不用担心程序内存泄漏了 ，但是如果我们写出这样的代码Auto_ptr<int> p0(new int); Auto_ptr p1(p0);,那就会出大事，会导致一块空间析构多次。为了解决这个问题我们又对拷贝构造进行了处理。
完整Auto_ptr类：

template<class T>
class Auto_ptr
{
public:
    Auto_ptr( T* ptr)//构造函数
        :_ptr(ptr)
    {}
    ~Auto_ptr()//析构函数
    {
        delete _ptr;
    }
    Auto_ptr(const Auto_ptr<T>& p)//拷贝构造
    {
        _ptr = p._ptr;
        p._ptr = NULL;
    }
    Auto_ptr<T>& operator=(const Auto_ptr<T>& p)//赋值运算符重载
    {
        if (this != &p)
        {
            delete _ptr;
            _ptr = p._ptr;
            p._ptr = NULL;
        }
        return *this;
    }
    T& operator*()
    {
        return *_ptr;
    }
    T* operator->()
    {
        return _ptr;
    }
protected:
    T* _ptr;
};

对于这里处理拷贝构造的思想上，一块内存只有一个人管理。（管理权转移）

虽然这里能很好解决拷贝构造的多次析构问题，但是又带来了另一个问题，如上p0的资源已经被释放，但是很容易让人误用p0的资源，这样就会造成程序崩溃。

scoped_ptr

在Auto_ptr采用资源管理权转移会造成错误访问的问题，scoped_ptr则采用防止拷贝构造发生，这样既不会产生多次虚构也不会造成错误访问。看看代码。

template<class T>
class Scoped_ptr
{
public:
    Scoped_ptr(T* ptr)
        :_ptr(ptr)
    {}
    ~Scoped_ptr()
    {
        delete _ptr;
    }
private:
    Scoped_ptr(Scoped_ptr<T>& sp); //声明拷贝构造为私有，不实现。
    Scoped_ptr<T>& operator=(const Scoped_ptr<T>& sp);
protected:
    T* _ptr;
};

采用声明为私有且不实现的方式，可以避免使用默认的拷贝构造，并且避免你自己在类外实现。这样就简单粗暴的防止拷贝构造的发生。但是还是有一点不方便，假如有人就是想使用拷贝构造对象。

shared_ptr

shared_ptr采用引用计数的方式，多个对象同时管理一块空间。看看代码实现。

template<class T>
class Shared_ptr
{
public:
    Shared_ptr(T* ptr)
        :_ptr(ptr)
        ,_pCount(new int(1))
    {}
    Shared_ptr(const Shared_ptr<T>& sp) //拷贝构造
    {
        _ptr = sp._ptr;
        _pCount = sp._pCount;
        ++(*_pCount);
    }
    Shared_ptr<T>& operator=(const Shared_ptr<T>& sp)//赋值运算符重载
    {
       if (*this != &sp)
       {
           if ((--(*_pCount)) == 0)
           {
               delete _ptr;
               delete _pCount;
           }
           _ptr = sp._ptr;
           _pCount = sp._pCount;
           ++(*_pCount);
       }
    }

    ~Shared_ptr()
    {
        if ((--(*_pCount)) == 0)
        {
            delete _ptr;
            delete _pCount;
        }
    }
protected:
    T* _ptr;
    T*_pCount;
};

这种方法可以很好的实现拷贝构造，同时不会造成前几种指针的问题。算的上很完美了，但是在某些方面依然有缺陷。比如看下面的代码。

void Shared_ptrTest()
{
    Shared_ptr<ListNode> cur = new ListNode;
    Shared_ptr<ListNode> next = new ListNode;
    cur->_next = next;
    next->_prev = cur;
}

这个链表会导致节点不能释放。看测试结果。

这就造成了循环引用，互相要释放资源，但是互相都占用对方的资源，谁也不放开。这就形成了死锁。
为了解决这个问题又有了weak_ptr。

　weak_ptr

看看weak_ptr的实现代码。

template<class T>
class Weak_ptr
{
public:
    Weak_ptr(Shared_ptr<T>& sp)
        :_ptr(sp._ptr)
    {}
    Weak_ptr()
        :_ptr(NULL)
    {}
    T* operator*()
    {
        return *_ptr;
    }

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

protected:
    T* _ptr;

};

看看测试结果

这就很好的解决了shared_ptr的问题。