智能指针的发展史

1 .智能指针的发展史
智能指针的发展要从RAII说起，RAII要求，资源的有效期与持有资源的对象的生命期严格绑定，即由对象的构造函数完成资源的分配(获取)，同时由析构函数完成资源的释放。在这种要求下，只要对象能正确地析构，就不会出现资源泄露问题。
（1）C++98提出auto _Ptr,auto_Ptr的设计是让两个指针指向同一块空间，但是这样会存在释放不当，出现程序崩溃的问题。
（2）在Boost库中设计了Scoped_Ptr,Shared_Ptr,Weak_Ptr这三种只能指针
（3）C++11经过进一步改进设计出了Unique_ptr,shared_ptr,Weak_ptr 这三种智能指针，Unique_ptr与相类似。
2.auto_Ptr/Scoped_Ptr/Shared_ptr/Weak_Ptr的设计思想、缺陷，以及它们各自的模拟实现？
（1） auto_Ptr的简单实现
auto_Ptr的几点注意事项：
auto_Ptr不能共享所有权
auto_Ptr不能指向数组
auto_Ptr不能作为容器的成员
不能通过赋值操作来初始化auto_Ptr

template<class T>class auto_Ptr{public:    auto_Ptr(T* ptr)        :_ptr(ptr)    {}    // ap2(ap1)    auto_Ptr(auto_Ptr<T>& ap)        :_ptr(ap._ptr)    {        ap._ptr = NULL;    }    // ap1 = ap2    auto_Ptr<T>& operator=(auto_Ptr<T>& ap)    {        if (this != &ap)        {            if (_ptr)                delete _ptr;            _ptr = ap._ptr;            ap._ptr = NULL;        }        return *this;    }    ~auto_Ptr()    {        if (_ptr)        {               delete _ptr;        }    }    T& operator*()    {        return *_ptr;    }    T* operator->()    {        return _ptr;    }protected:    T* _ptr;    };

可以看到一个很明显的缺陷 当使用了构造函数和拷贝构造函数时，原来的智能指针就失效了，使用权交给了新的智能指针，这种方式叫做管理权转移，任何时候只能有一个对象指向那块区域，当有看、两个指针指向同一块区域时，程序会崩溃

（2）Boost阶段 Boost阶段提出Scoped_Ptr 守卫指针 防拷贝

SharedPtr的提出主要是建立在AutoPtr的基础上，为了防止赋值和拷贝构造，可以用两种方法解决， 其一：只声明不实现
其二：声明成私有，这样，编译时就不会报错。
Scoped_Ptr的模拟实现

template<class T>class Scoped_Ptr{public:    Scoped_Ptr(T* ptr)        :_ptr(ptr)    {}    ~Scoped_Ptr()    {        delete _ptr;    }    T& operator*()    {        return *_ptr;    }    T* operator->()    {        return _ptr;    }private:    Scoped_Ptr(const Scoped_Ptr<T>&);    Scoped_Ptr<T>& operator=(const Scoped_Ptr<T>&);protected:    T* _ptr;};

Shared_Ptr的 简单实现
相对 于AutoPtr,Shared _Ptr 解决了指针共享的所有权问题，Shared_Ptr引入了引用计数，可以被自由的拷贝和赋值。

template<class T, class Del>class Shared_Ptr{public:    Shared_Ptr()        :_ptr(NULL)        ,_refCount(NULL)    {}    Shared_Ptr(T* ptr = NULL, Del del)        :_ptr(ptr)        ,_refCount(new int(1))        ,_del(del)    {}    ~Shared_Ptr()    {        if (--(*_refCount) == 0)        {            cout<<"delete"<<endl;            delete _ptr;            _del(_ptr);            delete _refCount;        }    }    Shared_Ptr(const Shared_Ptr<T, Del>& sp)        :_ptr(sp._ptr)        ,_refCount(sp._refCount)    {        ++(*_refCount);    }     sp2 = sp3    Shared_Ptr<T>& operator=(const Shared_Ptr<T>& sp)    {        if (this != &s)        if(_ptr != sp._ptr)        {            if (--(*_refCount) == 0)            {                delete _ptr;                delete _refCount;            }            _ptr = sp._ptr;            _refCount = sp._refCount;            ++(*_refCount);        }        return *this;    }    int RefCount()    {        return *_refCount;    }    T& operator*()    {        return *_ptr;    }    T* operator->()    {        return _ptr;    }    T* GetPtr() const    {        return _ptr;    }protected:    T* _ptr;    int* _refCount;    Del _del;};

Shared_ptr会带来循环引用问题。Weakptr 是用来解决Shared_ptr循环引用的缺陷问题，WeakPtr是一个弱指针，weak_ptr 设计的目的是为配合 shared_ptr 而引入的一种智能指针来协助 shared_ptr 工作, 它只可以从一个 shared_ptr 或另一个 weak_ptr 对象构造, 它的构造和析构不会引起引用记数的增加或减少.
WeakPtr的模拟实现
　　

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

虽然通过弱引用指针可以有效的解除循环引用, 但这种方式必须在程序员能预见会出现循环引用的情况下才能使用, 也可以是说这个仅仅是一种编译期的解决方案, 如果程序在运行过程中出
了循环引用, 还是会造成内存泄漏。
循环引用问题
你中有我，我中有你最后都导致双放都无法释放，最终导致内存泄漏，以双链表为例

struct ListNode{    Weak_Ptr<ListNode> _prev;    Weak_Ptr<ListNode> _next;    ~ListNode()    {        cout<<"~ListNode()"<<endl;    }};void TestCycleRef(){    Shared_Ptr<ListNode> cur = new ListNode;    Shared_Ptr<ListNode> next = new ListNode;    cur->_next = next;    next->_prev = cur;}

在这里，_next和_prev都是成员变量，第一块空间要想释放必须在第二块空间被释放之后才能释放，但由于第一块空间有一个节点指向第二块空间，所以只有第一块空间释放之后第二块空间才能释放，这样就带来了循环引用问题。