智能指针

智能指针

智能指针(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 <iostream>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<T> &s)        :_p(s._p)    {        s._p = NULL;    }    AutoPtr<T>& operator=(AutoPtr<T>& 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 <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");}

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

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

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

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

shared_ptr：共享指针

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

shared_array：共享数组

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

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

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

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