智能指针

智能指针

智能指针(smart pointer)是存储指向动态分配（堆）对象指针的类，用于生存期控制，能够确保自动正确的销毁动态分配的对象，防止内存泄露。它的一种通用实现技术是使用引用计数(reference count)。

智能指针类将一个计数器与类指向的对象相关联，引用计数跟踪该类有多少个对象共享同一指针。每次创建类的新对象时，初始化指针并将引用计数置为1；当对象作为另一对象的副本而创建时，拷贝构造函数拷贝指针并增加与之相应的引用计数；对一个对象进行赋值时，赋值操作符减少左操作数所指对象的引用计数（如果引用计数为减至0，则删除对象），并增加右操作数所指对象的引用计数；调用析构函数时，构造函数减少引用计数（如果引用计数减至0，则删除基础对象）。

智能指针有这么几种，这里没有列举完：
1）auto_ptr：自动指针
2）scoped_ptr：守卫指针
3）shared_ptr：共享指针
4）shared_array：共享数组
5）weak_ptr：弱指针

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

auto_ptr（自动指针）

1）auto_ptr 即是一种常见的智能指针。
智能指针通常用类模板实现：

#include 
using namespace std;
template <class T>
class AutoPtr
{
public:
    AutoPtr(const T*p)
        :_p(p)
    {}
    ~AutoPtr()
    {
        if (_p)
        {
            delete _p;
            _p = NULL;
        }
    }
    AutoPtr(const AutoPtr &s)
        :_p(s._p)
    {
        s._p = NULL;
    }
    AutoPtr& operator=(AutoPtr& s)
    {
        if (_p != s._p)
        {
            if (_p)
            {
                delete _p;
            }
            _p = s._p;
            s._p = NULL;
        }
        return *this;
    }
    T& operator*()
    {
        return *_p;
    }

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

private:
    T *_p;
};

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

为什么摒弃auto_ptr？

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

auto_ ptr的另一个缺陷是将数组作为auto_ ptr的参数：
auto_ptr pstr (new char[12] ); //申请数组空间
然后释放资源的时候不知道到底是利用delete pstr,还是 delete[] pstr;

所以总结一句就是：避免潜在的内存崩溃问题

然后我在网上还收集了关于auto_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

scoped_ptr：守卫指针

#include 
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 &s);
    ScopedPtr& operator=(ScopedPtr& s);
private:
    T *_p;
};

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

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

因为auto_ ptr的各方面都不行，甚至有点差的不行（在拷贝构造或者是赋值运算后，访问原来的指针程序就会崩溃），scoped_ptr的设计者就是为了避免这种崩溃，所以设计者想到了：不让你进行拷贝构造和赋值运算就可以避免这种情况。

方法：将拷贝构造和赋值运算符重载的声明给成私有，不给定义

假设我们在类外运用了拷贝构造和赋值运算，编译器会进行检查，发现这是不正确的。错误提示：无法访问 private 成员(在“ScopedPtr”类中声明)的错误。

当然这种方法肯定有效，但是你想在类外定义拷贝构造和赋值运算符重载也是可以的，尽管它俩在类里是私有的。（只是说可以，不用去做）

shared_ptr：共享指针

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

shared_array：共享数组

#include 
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;
};

shared_ array和shared_ptr不同的就是在申请和释放空间的时候由new变成了new[]，delete变成了delete[]，这个就不过多的解释了。

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才能被释放。

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

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