浅谈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实际上是管理权限的转移，此设计本身带有缺陷，不宜使用。

template<class T>    class Auto_ptr    {    public:    Auto_ptr(T* ptr)    :_ptr(ptr)    {}    Auto_ptr(Auto_ptr<T>& ap)    {    ap._ptr = NULL;    }    Auto_ptr<T>& operator=(Auto_ptr<T>& ap)    {    if(_ptr != ap._ptr)    {     delete _ptr;     _ptr = NULL;     _ptr = ap._ptr;     ap._ptr = NULL;    }    return *this;    }    ~Auto_ptr()    {    if(_ptr)    {    delete _ptr;    }    }    T* operator->()    {    return _ptr;    }    T& operator*()    {    return *_ptr;    }    private:    T* _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<T>& operator=(Scoped_ptr<T>& sp);Scoped_ptr(Scoped_ptr<T>& sp); private:T* _ptr;};指针功能明显受到限制，后来人们就不用了；于是行的智能指针诞生了。

shared_ptr采用了引用计数的思想，为需要拷贝和福祉的指针开启另一个空间。

temeplate<class T>class Shared_ptr{public:Shared_ptr(T* ptr)         :_ptr(ptr)         ,_ref(new int(1))         {}Shared_ptr(Shared_ptr<T>& sp)               :_ptr(sp.ptr)               ,_ref(sp.ref){  (*_ref)++;}         Shared_ptr<T>& operator=(Shared_ptr<T>& sp){if(_ptr != sp._ptr){if(--(*_ref) == 0){delete _ptr;deelte _ref;} delete _ptr; _ptr = sp._ptr; _ref = sp._ref; (*_ref)++;}return *this;}~Shared_ptr(){if(--(*_ref)==0){delete _ptr;delete _ref;}}T* operator->(){return _ptr;}T& operator*(){return _*ptr;}int Getref(){return *_ref} T* Getptr(){return _ptr;}protected:T* _ptr;int* _ref;};

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

解决循环引用的问题，需要一个弱指针。

   struct ListNode{    //WeakPtr<ListNode> _prev;    //WeakPtr<ListNode> _next;    SharedPtr<ListNode> _prev;    SharedPtr<ListNode> _next;    ~ListNode()    {        cout << "~ListNode()" << endl;    }};void TestCycleRef(){    SharedPtr<ListNode> cur = new ListNode;    SharedPtr<ListNode> next = new ListNode;    cout << "cur->Coun t:" << cur.RefCount() << endl;    cout << "next->Coun t:" << next.RefCount() << endl;    cur->_next = next;    next->_prev = cur;    cout << "cur->Coun t:" << cur.RefCount() << endl;    cout << "next->Coun t:" << next.RefCount() << endl;}

cur与next的引用计数均为2，且均无法释放，改为weak_ptr,(不增加引用计数)

template<class T>class WeakPtr{public:    WeakPtr()        :_ptr(NULL)    {}    WeakPtr(const SharedPtr<T>& sp)        :_ptr(sp.GetPtr())    {}    T& operator*()    {        return *_ptr;    }    T* operator->()    {        return _ptr;    }protected:    T* _ptr;};

如此解决了循环引用的问题。