C++ 智能指针（及循环引用问题）

何所谓智能指针？
所谓的智能指针就是智能/自动化的管理指指针所指向的动态资源的释放。
智能指针的产生是由于C++中没有内存的自动回收机制，每次new出来的空间都需要delete，而个别情况下，总是无法及时的delete，或者异常导致程序提早退出，造成内存泄漏，故而产生智能指针。

智能指针的发展可分为三个阶段
（1）auto_ptr c++98
（2）scoped_ptr/shared_ptr/weak_ptr boost库
（3）unique_ptr/shared_ptr/weak_ptr c++11

一、auto_ptr
auto_ptr实际上是管理权限的转移，此设计本身带有缺陷，建议什么情况下都不要使用。

#include<iostream>using namespace std;template <typename T>class Auto_ptr{public:    Auto_ptr(T* ptr = 0)        :_ptr(ptr)    {}    Auto_ptr(Auto_ptr<T>& p)        :_ptr(p._ptr)    {        p._ptr = NULL;    }    ~Auto_ptr()    {        delete _ptr;    }    Auto_ptr<T>&operator=(Auto_ptr<T>&p)    {        if (_ptr != p._ptr)        {            if (_ptr)            {                delete _ptr;            }            _ptr = p._ptr;            p._ptr = NULL;        }    }    T& operator*()    {        return *_ptr;    }    T& operator->()    {        return _ptr;    }private:    T* _ptr;};int main(){    Auto_ptr<int> p1(new int(10));    cout << *p1 << endl;    Auto_ptr<int> p2(p1);   //p1拷贝构造出p2    cout << *p1 << endl;    //再次访问p1的空间    system("pause");    return 0;}

auto_ptr的核心思想就是管理权限的转移，通过赋值运算符的重载或拷贝构造时，把p1置空，即将p1开辟的空间的管理权限转交给p2后，我们进行简单操作时并不会有问题：

但管理权限转交给p2后，我们再去访问旧指针时，就会出错，这并不是我们所期待的。

二、scoped_ptr
scoped_ptr又叫 守卫指针，用来防止拷贝，可以解决Auto_ptr的问题。
解决的方法：
（1）拷贝构造和赋值运算符的操作可以只声明，不定义。
（2）将声明为私有，防止定义。

template<class T>class Scoped_ptr{public:    Scoped_ptr(T*ptr)        :_ptr(ptr)    {}    ~Scoped_ptr()    {        if (_ptr)        {            delete _ptr;        }    }    T& operator*()    {        return *_ptr;    }    T* operator->()    {        return _ptr;    }private:    Scoped_ptr(const Scoped_ptr<T>& ptr);    Scoped_ptr<T>& operator=(Scoped_ptr& ptr);private:    T* _ptr;};int main(){    Scoped_ptr<int>p1(new int(1));    Scoped_ptr<int>p2(p1);    return 0;}

指针功能明显受到限制，后来人们就不用了；于是更合理的智能指针诞生了。

三、shared_ptr
当auto_ptr和scoped_ptr都不能满足我们实际需求时，这是我们引入shared_ptr，它的主要思想是引入了引用计数，使得多个指针可以指向同一块空间，当最后一个指针释放时才真正释放这块空间。

template<class T>class Shared_ptr{public:    Shared_ptr(T* ptr)        :_ptr(ptr)        ,_count(new int(1))      {}    ~Shared_ptr()    {        Release();    }    Shared_ptr(Shared_ptr<T>& p)        :_ptr(p._ptr)        , _count(p._count)    {        (*_count)++;    }    Shared_ptr<T>operator=(Shared_ptr<T>& p)    {        if (_ptr != p._ptr)        {            Release();  //先释放*this中的指针指向的空间            _ptr(p._ptr);               _count(p._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()    {        return *_count;    }    T* GetPtr()const    //获取指针    {        return _ptr;    }private:    T* _ptr;    int* _count;};int main(){    Shared_ptr<int> p1(new int(1));    Shared_ptr<int> p2(p1);    *p1 = 10;    cout << *p1 << endl;    cout << p1.GetCount() << endl;    cout << p2.GetCount() << endl;    system("pause");    return 0;}

上面的代码虽然简单的实现引用计数版的简化版智能指针Shared_ptr;但是存在着以下问题：
（1）引用计数更新存在着线程安全。
（2）循环引用的问题。
（3）定制删除器。

四、循环引用：
首先我们来举一个循环引用的例子：

template <typename T>class Node{public:    Node(const T& value)        :_pPre(NULL)        , _pNext(NULL)        , _value(value)    {        cout << "Node()" << endl;    }    ~Node()    {        cout << "~Node()" << endl;        cout << "this:" << this << endl;    }    shared_ptr<Node<T>> _pPre;    shared_ptr<Node<T>> _pNext;    T _value;};void Funtest(){    shared_ptr<Node<int>> sp1(new Node<int>(1));    shared_ptr<Node<int>> sp2(new Node<int>(2));    cout << "sp1.use_count:" << sp1.use_count() << endl;    cout << "sp2.use_count:" << sp2.use_count() << endl;    sp1->_pNext = sp2;    sp2->_pPre = sp1;    cout << "sp1.use_count:" << sp1.use_count() << endl;    cout << "sp2.use_count:" << sp2.use_count() << endl;}int main(){    Funtest();    system("pause");    return 0;}

我们可以看出，并没有调用析构函数，也就是没有对空间进行释放。
从上面shared_ptr的实现中我们知道了只有当引用计数减减之后等于0，析构时才会释放对象，而上述情况造成了一个僵局，那就是析构对象时先析构sp2,可是由于sp2的空间sp1还在使用中，所以sp2.use_count减减之后为1，不释放，sp1也是相同的道理，由于sp1的空间sp2还在使用中，所以sp1.use_count减减之后为1，也不释放。sp1等着sp2先释放，sp2等着sp1先释放,二者互不相让，导致最终都没能释放，内存泄漏。

解决方案：使用弱指针—->weak_ptr(不增加引用计数)

template <typename T>struct Node{public:    Node(const T& value)        :_value(value)    {        cout << "Node()" << endl;    }    ~Node()    {        cout << "~Node()" << endl;    }    weak_ptr<Node<T>> _pPre;    weak_ptr<Node<T>> _pNext;    T _value;};void Funtest(){    shared_ptr<Node<int>> sp1(new Node<int>(1));    shared_ptr<Node<int>> sp2(new Node<int>(2));    cout << "sp1.use_count:" << sp1.use_count() << endl;    cout << "sp2.use_count:" << sp2.use_count() << endl;    sp1->_pNext = sp2;    sp2->_pPre = sp1;    cout << "sp1.use_count:" << sp1.use_count() << endl;    cout << "sp2.use_count:" << sp2.use_count() << endl;}int main(){    Funtest();    system("pause");    return 0;}

至于weak_ptr具体是如何工作的我们可以点击链接，看大神的解释：
Boost智能指针——weak_ptr