shared_ptr：定制删除器 和 循环引用

前面我们介绍智能指针的时候，说了两个智能指针分别是：auto_ptr和scoped_ptr，auto_ptr有问题，为此，scoped_ptr的出现解决了这个问题，scoped_ptr太霸道，不允许别人和他共用一块内存空间，所以，我们还得想办法解决这个问题。

回想我们以前看过内容，当提到共用一块内存空间的时候，我们会想到什么？

当然是深拷贝和浅拷贝了，最后我们是不是有给出了一个写时拷贝，就是通过引用计数的方法来实现共用一块内存空间的。对于这个问题，C++中也给出了一个相同方法的解决方案，这就是shared_ptr。

首先，我们还是模拟一下shared_ptr：

template <typename T>
class SharedPtr
{
public:
    SharedPtr(T*ptr)
        :_Ptr(ptr)
        , _pcount(NULL)
    {
        if (_ptr)
        {
            _pcount=new int(1);
        }
    }

    SharedPtr(const SharedPtr<int> & sp)
    {
        _ptr = sp._ptr;
        _pcount = sp._pcount;
        ++(*_pcount);
    }

    ~SharedPtr()
    {
        if (0 == (--*_pcount))
        {
            delete _ptr;
            delete _pcount;
        }
    }

    SharedPtr<T>& operator=(const SharedPtr<T>& sp)
    {
        if (this != &sp)
        {
            if (_ptr != nullptr)
            {
                if (_pcount == 0)
                {
                    delete _ptr;
                    delete _pcount;
                }
            }
            else
            {
                _ptr = sp._ptr;
                _pcount = sp._pcount;
                ++(*_pcount);
            }
        }
        return *this;
    }

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

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

private:
    T* _ptr;
    int * _pcount;
};

定制删除器

#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
using namespace std;
//为解决文件指针
struct Fclose
{
    void operator()(FILE*& fp)
    {
        cout<< "Fclose()" << endl;
        fclose(fp);
        fp = NULL;
    }
};
//为解决malloc开辟的空间
template<class T>
struct Free
{
    void operator()(T*& p)
    {
        free(p);
        p = NULL;
    }
};
//一般情况下（使用new动态开辟的空间）
template<class T>
class Delete
{
public :
    void operator()(T*& p)
    {
        delete p;
        p = NULL;
    }
};
template<class T, class Destory = Delete<T> >
class SharedPtr
{
public :
    SharedPtr(T* ptr = 0)//构造函数
        :_ptr(ptr)
        ,_pCount(NULL)
    {
        if (_ptr)
        {
            _pCount = new int(1);
        }
    }
    SharedPtr(const SharedPtr<T>& sp)//拷贝构造函数
        :_ptr(sp._ptr)
        , _pCount(sp._pCount)
    {
        if (_ptr)
        {
            ++GetRef();
        }
    }
    //sp1 = sp2
    SharedPtr<T>& operator=(const SharedPtr<T>& sp)
    {
        //可有三种情况：①sp1._ptr = NULL  ②sp1的引用计数为1  ③sp1的引用计数大于1
        if (this != &sp)
        {
            Release();
            _ptr = sp._ptr;
            _pCount = sp._pCount;
            ++GetRef();
        }
        return *this;
    }
    //辅助函数
    void Release()
    {
        if (_ptr && --GetRef() == 0)
        {
            Destory()(_ptr);
            delete _pCount;
            _pCount = NULL;
        }
    }
 //析构函数
    ~SharedPtr()
    {
        Release();
    }

    int& GetRef()
    {
        return *_pCount;
    }
private:
    T* _ptr;
    int* _pCount;
};
void Test2()
{
    FILE* sp1 = fopen("test.txt", "rb");
    SharedPtr<FILE, Fclose> sp2(sp1);

    int* sp3 = (int*)malloc(sizeof(int));
    SharedPtr<int, Free<int> >sp4(sp3);

    int* sp5 = new int(1);
    SharedPtr<int> sp6(sp5);
}

int main()
{
    Test2();
    return 0;
}

循环引用

通过引用计数，我们解决了智能指针共享一块空间的问题，不过，shared_ptr还是有点问题，那就是循环引用的问题，什么是循环引用的问题呢？先来看一个例子：

struct Node  
{  
    int _data;  
    shared_ptr<Node> _next;  
    shared_ptr<Node> _prev;  
};  

void FunTest()  
{  
    shared_ptr<Node> sp1(new Node);  
    shared_ptr<Node> sp2(new Node);  
    cout << sp1.use_count() << endl;  
    cout << sp2.use_count() << endl;  

    sp1->_next = sp2;  
    sp2->_prev = sp1;  
    cout << sp1.use_count() << endl;  
    cout << sp2.use_count() << endl;  
}

我们先定义一个双链表节点，然后，我们再创建两个节点，并且让其链接起来，之后，我们再想要释放这两个节点的时候，会发现一个很有意思的现象，那就是，释放sp1的时候，必须先释放sp2，而想要释放sp2，那么必须先释放sp1，这就是循环引用的例子。

如图：

这是我画的两个节点，sp1的nest指向sp2，同时，sp2的prev指向sp1。那么sp1所指向的内存就被两个指针所管理，分别是：sp1和sp2->_prev；同样的，sp2所指向的内存空间就会被sp2和sp1->_nest所管理。

如果现在想要释放的是sp1，那么释放内存的时候其实是将其引用计数减去1，不是将这段空间释放。

那么，如何解决这个问题呢？

这里就不得不说：weak_ptr 了。