C++：四种智能指针

智能指针

智能指针在C++中非常常用，在学习指针指针的时候，发现创造它的大佬太牛逼了，为了以后学习，我就对它进行了一些总结

为马产生了智能智能

在平时写代码的时候，时常会忘记释放自己动态开辟出来的资源，因此我们在处理相关逻辑的时候就会变得异常的谨慎，但是即使这样，有一些隐形的一些问题，还是会导致资源被泄露了，让人防不胜防啊。有这样的困惑，就有大佬来帮我们解决这个困惑了，这不大佬们就创造出了智能指针这个东西。

啥是智能指针

智能指针顾明思议就是自动化、智能的管理指针所指向的动态开辟资源的释放。
智能指针具备三要素：

RAII
像指针一样
拷贝和赋值

RAII：资源分配即初始化，定义一个类来封装资源的分配和释放，在构造函数完成分配和初始化，在析构函数完成资源的释放。
所谓的像指针一样，也就是智能指针可以进行指针的诸多操作。
拷贝和赋值时智能指针需要具备的功能

智能指针的原理

管理类中的指针成员一般有两种方式：
1.一是采用值型的方式管理，每个类对象都保留一份指针指向的对象的拷贝；
2.另一种更优雅的方式是使用智能指针，从而实现指针指向的对象的共享。
我们现在所使用的智能指针(smart pointer)通用实现的技术是使用引用计数(reference count)。智能指针类将一个计数器与类指向的对象相关联，引用计数跟踪该类有多少个对象的指针指向同一对象。每次创建类的新对象时，初始化指针就将引用计数置为1；当对象作为另一对象的副本而创建时，拷贝构造函数拷贝指针并增加与之相应的引用计数；对一个对象进行赋值时，赋值操作符减少左操作数所指对象的引用计数（如果引用计数为减至0，则删除对象），并增加右操作数所指对象的引用计数；调用析构函数时，析构函数减少引用计数（如果引用计数减至0，则删除基础对象）。

智能指针的进化史

智能指针发展到现在共有四个版本流传于世，分别是auto_ptr，scoped_ptr，shared_ptr，weak_ptr

std::auto_ptr

我们先来说说智能指针那个年龄最大的auto_ptr，实现智能指针我们一般都要实现它的构造、析构、*、->、拷贝构造和赋值，那我就来先来实现下它:

template<class T>
class AutoPtr {
public:
    AutoPtr(T* ptr) 
        :_ptr(ptr)
    {}

    ~AutoPtr() {
        if (_ptr) {
            cout << "delete: " << _ptr << endl;
            delete _ptr;
        }
    }

    T& operator*() {
        return *_ptr;
    }
    T* operator->() {
        return _ptr;
    }
    //管理权转移
    AutoPtr(AutoPtr& ap)
        :_ptr(ap._ptr){
        ap._ptr = NULL;
    }

    AutoPtr& operator=(AutoPtr& ap) {
        if (this != &ap) {
            if (_ptr) {
                delete _ptr;
            }
            _ptr = ap._ptr;
            ap._ptr = NULL;
        }
        return *this;
    }
private:
    T * _ptr;
};

在标准库中，它还将拷贝和构造函数定义为私有，并且只声明不实现，以此来实现防拷贝。
auto_ptr的赋值和拷贝构造存在于一个管理权转移的操作，也就是说将赋值和拷贝构造结束后，就只会有一个指针拥有管理权，另外的一个指针就会指向NULL，这样就很容易造成NULL指针的解引用，从而导致内存崩溃。
std::auto_ptr是年龄最大的智能指针，如那句老话青出于蓝而胜于蓝，因此它也就成为了缺陷最严重的智能指针了，它存在着以下缺陷：

不要让auto_ptr保存一个非动态开辟的空间的指针，因为auto_ptr会自动调用析构函数，从而delete掉那块空间，但是非动态开辟的空间又是不可释放的；
不要让两个auto_ptr指向同一个指针，因为在它的拷贝构造函数中，当资源管理权转移后，会进行置空操作，这样就会导致两个auto_ptr都管理不了指针了；
不要让auto_ptr指向一个指针数组，因为它使用的是delete而不是delete[]；
不要将auto_ptr存储在容器中，因为在复制和拷贝构造后，原指针就会使用不了了；
因此，对于这个元老级人物，太过元老了，我们就不要用它了。

boots::scoped_ptr

scoped_ptr的实现原理就是防止对象间的拷贝和赋值，它将拷贝构造函数和赋值运算符重载函数设置为了私有并且只声明不实现，这种做法简单而粗暴，但是却很好的防止了别人在类外进行拷贝和赋值，提高了代码的安全性。

template
class ScopedPtr {
public:
    ScopedPtr(T* ptr)
        :_ptr(ptr)
    {}

    ~ScopedPtr() {
        cout << "delete:" << _ptr << endl;
        delete _ptr;
    }

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

    T* operator->() {
        return _ptr;
    }
    //防拷贝，声明为私有，并且只声明不实现
private:
    ScopedPtr(const ScopedPtr& sp);
    ScopedPtr& operator=(const ScopedPtr& sp);
private:
    T * _ptr;
};

boots::scoped_ptr的缺陷就在于，它不能进行拷贝和赋值，因为它严格的限制拷贝操作，也就是scoped_ptr不能转移所有权。因此如果只是为了防止内存泄漏，而不需要对指针进行拷贝和赋值，scoped_ptr就会想你招手。

boots::scoped_array

这个使智能指针的数组，使用的次数非常少，他和scoped_ptr基本原理差不多，只是他少了指针的一些操作，而重载了[].

template
class ScopedArray {
public:
    ScopedArray(T* ptr)
        :_ptr(ptr)
    {}

    ~ScopedArray() {
        cout << "delete:" << _ptr << endl;
        delete[] _ptr;
    }
    T& operator[](size_t index) {
        return _ptr[index];
    }
    //也是为了防拷贝
private:
    ScopedArray(const ScopedArray& sp);
    ScopedArray& operator=(const ScopedArray& sp);
private:
    T * _ptr;
};

这个就只需要了解下就行了

boots::share_ptr和boots::weak_ptr

scoped_ptr问世后，虽然可以防止内存的泄漏，但是它不能拷贝赋值这就很难受，秉承着偷懒的思想，大佬们又想出了一个牛掰的智能指针share_ptr，它就很好的解决了scoped_ptr不能实现的拷贝赋值。
share_ptr相对于其它智能指针的区别就在于它维护了一个引用计数，用于检测当前对象多管理的指针是否还被其它的智能指针使用，构造函数，引用计数+1，析构函数，引用计数-1，判断是否为0， 为0就释放这个指针和这个引用计数空间。

C++11去掉了share_array，因为他们提供了定置删除器，仿函数

template<class T>
class WeakPtr;
template<class T>
class SharePtr {
    friend class WeakPtr;
public:
    SharePtr(T* ptr)
        :_ptr(ptr)
    {
        _pcount = new int(1);
    }

    ~SharePtr() {
        if (--(*_pcount) == 0) {
            cout << "delete ptr:" << _ptr << endl;
            cout << "delete pcount:" << *_pcount << endl;
            delete _ptr;
            delete _pcount;
        }
    }

    SharePtr(const SharePtr& sp)
        :_ptr(sp._ptr)
        ,_pcount(sp._pcount)
    {   
        ++(*_pcount);
    }

    SharePtr& operator=(const SharePtr& sp) {
        if (_ptr != sp._ptr) {
            if (--(*_pcount) == 0) {
                delete _pcount;
                delete _ptr;
            }
            _ptr = sp._ptr;
            _pcount = sp._pcount;
            ++(*_pcount);
        }
        return *this;
    }
    T& operator*() {
        return *_ptr;
    }

    T* operator->() {
        return _ptr;
    }
private:
    T *_ptr;
    int *_pcount;
};

weak_ptr是为了解决share_ptr的引用计数问题，因此两个设为友元类，后面会具体说。

share_ptr成功在它的应用计数，但是它的缺陷也在于引用计数，例如在双向链表里，当只有两个节点时，cur的prev指针指向NULL，next节点的next指针执行NULL，如果实现为share_ptr的话就会出现循环引用的问题，如下图

如图中，_next指针管理着next节点，_prev指针管理着cur节点，因此他们的引用计数都为2，当需要销毁节点的时候，当cur需要销毁的时候，它的引用计数-1，但是依旧不为0，因此它还不能被销毁，这就会造成函数结束，而cur和next所维护的空间依旧没有被销毁，这样就会造成内存泄漏，这就是share_ptr的循环引用问题
因此为了解决循环引用问题，一般有这么几种解决方法：

当只剩下最后一个引用的时候需要手动的打破循环引用的对象
使用weak_ptr(弱引用)的智能指针来解决
我们常用weak_ptr和share_ptr搭配使用来解决share_ptr的循环引用问题，它的实现如下：

template
class WeakPtr {
public:
    WeakPtr(const SharePtr& sp)
        :_ptr(sp._ptr)
    {}

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

    T* operator->() {
        return _ptr;
    }
private:
    T * _ptr;
};

这个代码就需要和前面的share_ptr结合着来看。
weak_ptr没有引用计数，就不会存在循环引用问题。
还有一种方法可以来解决循环引用问题，就是定制删除器，它是通过仿函数来解决这个问题

template<typename T>
struct Delete{
    void operator()(T* ptr)
    {
        cout << "Delete:" << ptr << endl;
        delete(ptr);
    }
};

其他

intrusive_ptr也是boots库提供的一个智能指针，它和share_ptr大致相同，它们之间的区别是在与，intrusive_ptr的引用计数是手动计数的，因此它就显得很鸡肋，因此在C++11里面就没有intrusive_ptr这个智能指针了。

总结

总的来说，对于智能指针我们不要使用auto_ptr,如果不需要拷贝和赋值，就使用scoped_ptr，当要使用拷贝和赋值时，就使用share_ptr，当又会涉及循环引用问题，就搭配着weak_ptr一起使用。