c++智能指针（SmartPtr）简单剖析

一、什么是智能指针？

智能指针(smart pointer)：是存储指向动态分配（堆）对象指针的类，用于生存期控制，能够确保自动正确的销毁动态分配的对象，防止内存泄露。它的一种通用实现技术是使用引用计数(reference count)。由于c++语言没有自动回收机制，写代码时总要new一个空间，用完之后必须要delete掉，有时候程序代码过于复杂，经常会忘记delete内存，从而导致程序异退出，因此就有了智能指针来解决问题。
下面我们主要来解析几种常见的智能指针：
1）auto_ptr：自动指针
2）scoped_ptr：守卫指针
3）shared_ptr：共享指针
4）shared_array：共享数组
5）weak_ptr：弱指针

智能指针就是模拟指针动作的类。所有的智能指针都会重载 -> 和 * 操作符。智能指针还有许多其他功能，比较有用的是自动销毁。这主要是利用栈对象的有限作用域以及临时对象（有限作用域实现）析构函数释放内存。当然，智能指针还不止这些，还包括复制时可以修改源对象等。智能指针根据需求不同，设计也不同（写时复制，赋值即释放对象拥有权限、引用计数等，控制权转移等）。

二、模拟实现与分析

auto_ptr(自动指针）

atou_ptr的原理是管理权限转移（新的指针在拷贝构造或者赋值原来的指针时，会把原来的指针置空，让新的指针指向原来指针指向的空间，所以称之为自动指针）所以访问原来的指针时，程序会崩溃。
模拟实现auto_ptr

#include<iostream>
using namespace std;
template<class T>
class  AutoPtr
{
public:
    AutoPtr(const T*x)
        :_x(x)
    {}

    ~AutoPtr()
    {
        if(_x)
        {
            delete _x;
            _x=NULL;
        }
    }

    AutoPtr(const AutoPtr<T> &s)
        :_x(s._x)
    {
        s._x=NULL;
    }

     AutoPtr<T>& operator=(AutoPtr<T>&s)
     {
         if(_x!=s._x)
         {
             if(_x)
             {
                 delete _x;
             }
             _x=s._x;
             s._x=NULL;

         }
         return *this;

     }

     T& operator*()
     {
         return *_x;
     }



private:
    T* _x;
};

T* operator->()
{
    return _x;
}

void test()
{
    int *p=new int;
    AutoPtr<int> ap(x);
    *ap=1;//出错
}

auto_ptr的缺陷：
1.将数组作为auto_ptr的参数，auto_ptr pstr(new char[12]);//申请数组空间，然后释放资源的时候不知道用delete pstr，还是delete[] pstr；
2.管理权限转移的时候，原指针置空，访问原指针时，程序崩溃。

atou_ptr的几种注意事项：
1、auto_ptr不能共享所有权。
2、auto_ptr不能指向数组
3、auto_ptr不能作为容器的成员。
4、不能通过赋值操作来初始化auto_ptr
std::auto_ptr p(new int(42)); //OK
std::auto_ptr p = new int(42); //ERROR
这是因为auto_ptr 的构造函数被定义为了explicit
5、不要把auto_ptr放入容器

总结：auto_ptr存在潜在的内存崩溃问题，尽量不要使用auto_ptr

scoped_ptr : 守卫指针

scoped_ptr守卫指针，又称防拷贝指针，也就是在进行拷贝构造和赋值运算就报错，由于auto_ptr在拷贝构造或者赋值运算后，访问原来的指针时程序就会崩溃，为了避免这种问题，scoped_ptr就产生了。
scoped_ptr模拟实现：

 #include<iostream>
using namespace std;
template<class T>

class ScopedPtr
{
public:
    ScopedPtr(const T*p)
        :_p(p)
    {}
    ~ScopedPtr()
    {
        if(_p)
        {
            delete _P;
            _P=NULL;
        }
    }
    T& operator*()
    {
        return *_p;
    }

    T* operator->()
    {
        return _P;
    }

private:
    ScopedPtr(const ScopedPtr<T> &s);
    ScopedPtr<T>& operator=(ScopedPtr<T>& s);
private:
    T* _P;

};

void Test()
{
    int *p=new int;
    ScopedPtr<int> ap(p);
}

int main()
{
    Test();
    system("pause");
}

由上面的代码可见scoped_ptr是将拷贝构造和赋值运算符的重载的声明成私有，不给定义，从而实现守卫指针的。
那么我们考虑这样一种情况是否可行？

假设我们在类外运用了拷贝构造和赋值运算，编译器会进行检查，发现这是不正确的。错误提示：无法访问 private 成员(在“ScopedPtr”类中声明)的错误。
当然这种方法肯定有效，但是你想在类外定义拷贝构造和赋值运算符重载也是可以的，尽管它俩在类里是私有的。（只是说可以，不用去做）

shared_ptr : 共享指针

shared_ ptr是可以拷贝和赋值的，shared_ ptr的管理机制其实并不复杂，就是对所管理的对象进行了引用计数，当新增一个shared_ ptr对该对象进行管理时，就将该对象的引用计数加一；减少一个shared_ptr对该对象进行管理时，就将该对象的引用计数减一，如果该对象的引用计数为0的时候，说明没有任何指针对其管理，才调用delete释放其所占的内存。这也是最常用的一种。

#include <iostream>
using namespace std;
template <class T>
class SharedPtr
{
public:
    SharedPtr(T* s)
        :_p(s)
        , _count(new int(1))
    {}

    ~SharedPtr()
    {
        if (--(*_count) == 0)
        {
            delete _p;
            _p = NULL;
            delete _count;
            _count = NULL;
        }
    }

    SharedPtr(SharedPtr<T>& s)
        :_p(s._p)
        , _count(s._count)
    {
        (*_count)++;
    }

    SharedPtr<T>& operator= (SharedPtr<T>& s)
    {
        if (_p != s._p)
        {
            if (--(*_count) == 0)
            {
                delete _p;
                _p = NULL;
                delete _count;
                _count = NULL;
            }

            _p(s._p);
            _count(s._count);
            (*_count)++;
        }
        return *this;
    }

    T& operator*()
    {
        return *_p;
    }

    T* operator->()
    {
        return _p;
    }

    int GetCount()
    {
        return *_count;
    }

    T* GetPtr() const
    {
        return _p;
    }

protected:
    T* _p;
    int* _count;
};

shared_array : 共享数组

shared_ array和shared_ptr不同的就是在申请和释放空间的时候由new变成了new[]，delete变成了delete[]，这个就不过多的解释了。
下面看代码模拟实现：

#include <iostream>
using namespace std;
template <class T>
class SharedArray
{
public:
    SharedArray(T* s)
        :_p(s)
        , _count(new int(1))
    {}

    ~SharedArray()
    {
        if (--(*_count) == 0)
        {
            delete[] _p;//和SharedPtr有变化
            _p = NULL;
            delete _count;
            _count = NULL;
        }
    }

    SharedArray(SharedArray<T>& s)
        :_p(s._p)
        , _count(s._count)
    {
        (*_count)++;
    }

    SharedArray<T>& operator= (SharedArray<T>& s)
    {
        if (_p != s._p)
        {
            if (--(*_count) == 0)
            {
                delete[] _p;//和SharedPtr有变化
                _p = NULL;
                delete _count;
                _count = NULL;
            }

            _p(s._p);
            _count(s._count);
            (*_count)++;
        }
        return *this;
    }

    T& operator*()
    {
        return *_p;
    }

    T* operator->()
    {
        return _p;
    }

    int GetCount()
    {
        return *_count;
    }

    T* GetPtr() const
    {
        return _p;
    }

protected:
    T* _p;
    int* _count;
};

weak_ptr : 弱指针

先看代码：

template <class T>
class WeakPtr
{
public:
    WeakPtr()
        :_p(NULL)
    {}

    WeakPtr(const SharedPtr<T>& s)
        :_p(s._p)
    {}

    ~WeakPtr()
    {
        if (_p)
        {
            delete _p;
            _p = NULL;
        }
    }

    T& operator*()
    {
        return *_p;
    }

    T* operator->()
    {
        return _p;
    }

private:
    T* _p;
};

weak_ ptr用来解决shared_ ptr可能引起的循环引用的问题，weak_ ptr不会增加shared_ptr所指向空间的引用计数。

循环引用是这样的：

我们实例化两个shared_ ptr的对象，ptr1指向一块空间，ptr2指向另一块空间。那么按照shared_ ptr的机制，此时ptr1和ptr2指针所指向的空间计数count都为1，没有毛病。
但是假设两个shared_ ptr的对象中还有next指针和prev指针。我们让ptr1中的next指针指向ptr2指向的空间时，ptr2所指向的空间中的count计数变成2；ptr2的prev指针指向ptr1指向的空间，ptr1所指向的空间计数count也变成了2。

问题来了！！！
当ptr1释放的时候，它指向的空间计数count必须为0，此时，ptr2中的prev指针也指向该空间，只有当ptr2中的prev指针被释放了，ptr1才能被释放；

要释放ptr2中的prev指针，它指向的空间计数count必须为0，此时，ptr1中的next指针也指向该空间，只有当ptr1中的next指针被释放了，ptr2才能被释放。

发现了吧，挺绕口的，这就是存在的循环引用的问题。

弱指针并不修改该对象的引用计数，这意味这弱引用它并不对对象的内存进行管理，在功能上类似于普通指针，然而一个比较大的区别是，弱指针能检测到所管理的对象是否已经被释放，从而避免访问非法内存.