动态内存管理和智能指针 2.0 -- shared_ptr

shared_ptr出现原因

通过第一章的学习，我们知道不管是auto_ptr合适scoped_ptr都是存在缺陷的，于是我们必须想出一个方法既能很好的管理我们的内存，而且在使用的时候，可以多个指针指向一个内存，这个时候就出现了shared_ptr。

shared_ptr的实现原理

shared_ptr使用的引用计数的浅拷贝的形式，这个时候是不需要使用引用计数的写时拷贝的，因为多个指针指向的是同一个动态的内存空间，当其中的一个内存空间改变的时候，其他的内容也是相应的改变的。
这个时候我们的shared_ptr这个类的成员变量中就要有一个指针，用于指向一个动态开辟的存储空间，还需要有一个用于计数的指针，这个指针指向一个动态开辟的内存空间，一般是整型的，这个整型 变量中存放的是我们指向同一个空间的个数，然后这个动态的整型空间只在构造函数的使用开辟出来，其他的拷贝构造函数还有赋值运算符的重载 的时候直接的使用了。

简单代码实现

template<class T>
class Shared_Ptr
{
public:
    Shared_Ptr(T* ptr)
        :_ptr(ptr)
        ,_count(new int(1))
    {
    }

    Shared_Ptr(const Shared_Ptr& ptr)
        :_ptr(ptr._ptr)
        , _count(ptr._count)
    {
        (*_count)++;
    }
    Shared_Ptr& operator=(const Shared_Ptr& ptr)
    {
        if (this == &ptr)
        {
            return *this;
        }

        else
        {
            if (!--(*_count))
            {
                delete _ptr;
                delete _count;
                cout << "delete older" << endl;
            }
            _ptr = ptr._ptr;
            _count = ptr._count;
            (*_count)++;
        }
        return *this;
    }

    ~Shared_Ptr()
    {
        (*_count)--;
        if ((*_count) == 0)
        {
            delete _ptr;
            delete _count;
            cout << "delete" << endl;
        }
    }

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

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


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

代码分析

构造函数
当我们使用构造函数的时候，这个时候肯定是已经动态开辟了一个内存空间的，所以我们这个时候也给我们_count指针动态的开辟一个空间，并且这个空间的值是1，因为此时一定是有一个空间了。

拷贝构造函数
拷贝构造函数的时候，我们是让一个已经存在的对象去初始化另一个对象，所以这个时候我们只需要让当前对象的指针指向那个动态的空间，同时时当前对象的计数指针也指向那个对象的计数空间，并且使当前对象的计数值加1，因为这个时候已经有两个对象 指向了一个动态的空间了。

析构函数
析构函数的时候，我们需要把引用计数减一，这个时候再去判断我们的引用计数的值是否为0，如果是0，这个时候就需要释放我们的动态管理的空间，同时释放掉我们的引用计数的动态空间，同时需要把这两个指针置为NULL。

赋值运算符的重载

该检查的是，这个赋值是不是自赋值,如果是 自赋值，这个时候直接返回该对象 即可了，还需要注意的是，我们 的引用计数不需要加1.如果不是自赋值，此时需要把当前对象的引用计数减1，同时判断减1之后应用计数是不是为0，如果是0则需要释放掉，如果不是0，就不要管了，然后接下来把我们当前指针指向被赋值的那个空间即可。

循环引用和weak_ptr

当下面的代码的时候会出现一种情况就是 循环引用，首先看代码，下面的代码是我们定义的一个结构体

struct Str
{
    Shared_Ptr<Str> _prev;
    Shared_Ptr<Str> _next;
};

再来看我们的构造函数

Shared_Ptr(T* ptr)
        :_ptr(ptr)
        ,_count(new int(1))
    {
    }

上面的构造函数中，我们的构造函数没有缺省值，会报错，因为我们在定义_prev和_next的时候，没有传入参数，所以我们需要把我们的构造函数改成下面的样子，就是把缺省值赋值为NULL。
这个时候我们写一个测试用例

Shared_Ptr<Str> a = new Str;
Shared_Ptr<Str> b = new Str;

这个时候会打印出六个delete，因为我们new出来的两个对象本身是有两个对象的，所以析构的时候，会析构这里面的两个一个是_next一个是_prev，然后我们的a和b本身也是指向对象的，所以一共析构了六次。

隐患问题 – 循环引用

如果我们是像下面的方式 使用它，就会出现循环 引用的问题，请看下面的代码

    Shared_Ptr<Str> a = new Str;
    Shared_Ptr<Str> b = new Str;


    a->_next = b;
    b->_prev = a;

结合刚刚的分析，我们来分析上面的一段程序，首先是a和b分别指向了两个new出来的对象 ，然后这两个对象 里面的next和prev分别指向了两个对象，接着 执行a->_next = b;
b->_prev = a;的时候，会调用赋值运算符的重载，然后就是a里面的next由原来的内容指向了b，b里面 的prev由原来的内容指向了a；这个时候问题就来了，b这个指向指向的内存空间有两个指针指向着，一个是b自己，一个是a->_next，所以析构的时候不会释放内存空间，这不是我们想看到的结果。也可以这样子分析，就是我们的a和b析构的时候，只是 把引用计数减1，接下来析构a->_next和b->prev的时候，都是相互依赖彼此的，所以都释放不了，这就是循环引用。

weak_ptr

于是为了解决上面的循环引用的特殊场景，配合着shared_ptr设计出了一个weak_ptr，代码如下

#include<iostream>
using namespace std;

template<class T>
class Weak_ptr;

template<class T>
class Shared_Ptr
{

public:
    friend class Weak_ptr<T>;
    Shared_Ptr(T* ptr = NULL)
        :_ptr(ptr)
        ,_count(new int(1))
    {
    }

    Shared_Ptr(const Shared_Ptr& ptr)
        :_ptr(ptr._ptr)
        , _count(ptr._count)
    {
        (*_count)++;
    }

    Shared_Ptr& operator=(Shared_Ptr& ptr)
    {
        if (this == &ptr)
        {
            return *this;
        }

        else
        {
            if (!--(*_count))
            {
                delete _ptr;
                delete _count;
                cout << "delete older" << endl;
            }
            _ptr = ptr._ptr;
            _count = ptr._count;
            (*_count)++;
        }
        return *this;
    }

    ~Shared_Ptr()
    {
        (*_count)--;
        if ((*_count) == 0)
        {
            delete _ptr;
            delete _count;
            _ptr = NULL;
            _count = NULL;
            cout << "delete" << endl;
        }
    }

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

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


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

template<class T>
class Weak_ptr
{
public:
    Weak_ptr()
        :_ptr(NULL)
    {}
    Weak_ptr(Shared_Ptr<T> ptr)
    {
        _ptr = ptr._ptr;
    }
    T* operator->()
    {
        return _ptr;
    }

private:
    T* _ptr;
};


struct Str
{
    Weak_ptr<Str> _prev;
    Weak_ptr<Str> _next;
    int _a;
};


void TestPtr()
{


    Shared_Ptr<Str> a = new Str;
    Shared_Ptr<Str> b = new Str;

    a->_next = b;
    b->_prev = a;
    a->_next->_a = 0;
    cout << b->_a;

}

首先我们看Weak_ptr，它的成员变量是T* _ptr;此时我们的Str那个自定义的结构体中的指针就可以改成了Weak_ptr的形式，因为我们的Weak_ptr维护的是一个普通的指针，但是我们在使用的时候需要用到_next指向一个Shared_ptr的对象，所以这个时候，我们不要把Weak_ptr的拷贝构造函数的参数写成是Shared_ptr，然后赋值的时候，需要把Shared_ptr的_ptr赋值给Weak_ptr的_ptr，但是Shared_ptr中的_ptr是 私有的，所以这个时候我们在Shared_ptr里面把Weak_ptr声明为友元。但是这个时候又出现了一个 问题就是，我们的他声明为友元之后，编译器找不到我们的友元类，因为我们的Weak_ptr的定义部分是在Shared_ptr的后面，所以这个时候，需要在Shared_ptr的前面声明我们的Weak_ptr。

定制防函数

所谓的防函数就是让我们的类看起来像是函数一样
举一个简单的例子，看下面的代码

struct Compare
{
    bool operator()(int a,int b)
    {
        return a > b;
    }
};

void test()
{
    Compare com;
    cout << com(1,2);
}

类Compare是我们定制的一个防函数，下面的test就是我们把他 当成一个函数来使用它

为什么要引入防函数呢，因为我们在使用的时候上面的Shared_ptr的时候，我们管理的内存 空间可能是一个FILE*的一个指针，这个时候我们就不能只使用delete来释放我们的空间，这个时候我们就需要定制一个防函数，把它作为一个参数放在构造函数 中，同时我们的Shared_ptr的成员变量里面需要定义一个这样的变量。

请看下面的代码

#include<iostream>
using namespace std;
#include<assert.h>
#pragma once
#define _CRT_SECURE_NO_WARNINGS 1



struct DelFile
{
    void operator()(FILE* f)
    {
        fclose(f);
        cout << "fclose" << endl;
    }
};


struct DelDel
{
    void operator()(void* p)
    {
        assert(p);
        delete p;
        cout << "delete" << endl;
    }
};

template<class T,class Del>
class Weak_ptr;

template<class T,class Del>
class Shared_Ptr
{

public:
    friend class Weak_ptr<T,Del>;
    Shared_Ptr(T* ptr,Del d)
        :_ptr(ptr)
        ,_count(new int(1))
        , _del(d)
    {
    }

    Shared_Ptr(const Shared_Ptr& ptr)
        :_ptr(ptr._ptr)
        , _count(ptr._count)
    {
        (*_count)++;
    }

    Shared_Ptr& operator=(Shared_Ptr& ptr)
    {
        if (this == &ptr)
        {
            return *this;
        }

        else
        {
            if (!--(*_count))
            {
                del(_ptr);
                delete _count;
                cout << "delete older" << endl;
            }
            _ptr = ptr._ptr;
            _count = ptr._count;
            (*_count)++;
        }
        return *this;
    }

    ~Shared_Ptr()
    {
        (*_count)--;
        if ((*_count) == 0)
        {
            _del(_ptr);
            delete _count;
            _ptr = NULL;
            _count = NULL;
            //cout << "delete" << endl;
        }
    }

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

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


protected:
    T* _ptr;
    int* _count;
    Del _del;
};

template<class T, class Del>
class Weak_ptr
{
public:
    Weak_ptr()
        :_ptr(NULL)
    {}
    Weak_ptr(Shared_Ptr<T,Del> ptr)
    {
        _ptr = ptr._ptr;
    }
    T* operator->()
    {
        return _ptr;
    }

private:
    T* _ptr;
};


struct Str
{
    Weak_ptr<Str,DelDel> _prev;
    Weak_ptr<Str, DelDel> _next;
    int _a;
};

void TestFile()
{
    DelFile d;
    Shared_Ptr<FILE, DelFile> a(fopen("w.ss","w"),d);   //注意这里传参的时候，首先要实例化一个对象
            //我一开始使用的是Shared_Ptr<FILE, DelFile> a(fopen("w.ss","w"),DelFile d)
            //这种方式显然是错误的，我不能在一个函数里面去实例化一个对象
}


void TestPtr()
{
    DelDel d;
    Shared_Ptr<Str, DelDel> a(new Str, d);
    Shared_Ptr<Str, DelDel> b(new Str, d);

    a->_next = b;
    b->_prev = a;
    a->_next->_a = 0;
    cout << b->_a;



}

struct Compare
{
    bool operator()(int a,int b)
    {
        return a > b;
    }
};

void test()
{
    Compare com;
    cout << com(1,2);
}