智能指针的使用以及模拟实现

---

智能指针

在C语言中，我们初识了指针这一概念，在C++中，我们不断对于指针进行研究和使用，指针的存在是C/C++的一大特色，但是由于非规范操作，可能会导致指针并没有被释放，从而导致了内存泄漏、野指针等问题。

C++中为了解决这一问题，推出了智能指针这一概念

在C++98中推出了auto_ptr，第一代智能指针，来进行对于指针资源管理

在C++11中相继推出三种智能指针，unique_ptr、shared_ptr、weak_ptr

在学习异常之前，我们知道出现内存泄漏一般是由于指针不规范使用导致，但是异常的出现，可跳出当前作用域这一行为，也可以导致内存泄漏的发生。

//智能指针
void Add()
{
    int* ptr = new int[10];//我们在堆上动态开辟空间
    //如果上述ptr开辟空间失败，抛异常，被func中的catch抓住，就不会执行delete ptr
    delete ptr;
}
void func()
{
    try {
        Add();
    }
    catch(const exception& e)
    {
        cout << e.what() << endl;//输出异常
    }
}
int main()
{
    func();
    return 0;
}

所以，我们就算有时候操作很规范，也会可能导致内存泄漏，智能指针的出现就会解决这一问题

内存泄漏

我们先介绍一些内存泄漏的危害性，在工程项目中，如果出现了内存泄漏，且每一次泄漏一小部分，很难被察觉，那么就会在启动该项目的一周，一个月后，发现该项目的运行越来越卡顿，最后项目崩溃。

如果内存泄漏很慢，这是最难被发现的

如果泄漏很快，说不定项目启动当天就能发现，从而解决

由内存泄漏导致出现的项目崩溃，是为事故，轻则奖金扣除，总则打包回家！！！

C/C++程序中主要是两个方面可能会出现内存泄漏，堆内存泄漏和系统资源泄漏

堆内存泄漏

堆内存泄漏，就是我们在程序中使用malloc/calloc/realloc/new等关键字从堆中进行分配内存资源，在该资源使用完毕后，没有合理使用free/delete等删掉该资源（释放资源），从而导致的内存泄漏。

系统资源泄漏

指程序使用系统分配的资源，比方套接字、文件描述符、管道等没有使用对应的函数释放
掉，导致系统资源的浪费，严重可导致系统效能减少，系统执行不稳定。

规避内存泄漏方法

1.规范使用代码（但是异常还是可能会有内存泄漏的风险）

2.使用RAII思想或者智能指针来进行管理资源（申请和释放）

3.使用第三方检测工具来实现对于程序的内存泄漏的检查

智能指针的使用和原理

智能指针的实现，使用了RALII的原理，即利用对象生命周期来控制程序资源的思想，用类进行包装，从而通过类自带的构造和析构函数，实现对于资源的申请和释放，从而避免内存泄漏

在对象构造的时候，进行资源的申请；在对象析构的时候，对资源进行释放

namespace why{
    //设计实现简单的智能指针
    template<class T>
    class auto_ptr
    {
    public:
        auto_ptr(T* ptr=nullptr)
            :_ptr(ptr)
        {
            //ptr = new int;//实现在构造的时候，申请资源
            cout << "构造函数，申请资源" << endl;
        }
        ~auto_ptr()
        {
            cout << "析构函数，释放资源" << endl;
            delete _ptr;//在析构的时候，释放资源
        }
        T& operator*()
        {
            return *_ptr;
        }
        T* operator->()
        {
            return _ptr;
        }
    private:
        T* _ptr;
    };

}

int main()
{
    why::auto_ptr<string> aaa;//默认构造
    why::auto_ptr<int> a(new int);//在构造的时候进行申请资源
    auto_ptr<string> a(new string("xxxx"));
        
    return 0;
}

C++98/C++11智能指针

auto_ptr

c++98中推出的智能指针，可以对于资源进行管理，特点是可以实现管理权的转移（转移后，将被转移的指针指向为nullptr），但是在某种情况下会出现野指针的风险

int main()
{
    //使用智能指针auto_ptr
    auto_ptr<string> ptr1(new string("xxx"));
    
    auto ptr2 = ptr1;
    cout << ptr1.get() << endl;
    cout << ptr2.get() << endl;//get函数，得到二进制地址
    cout << *ptr1 << endl;
    return 0;
}

所以说，auto_ptr在设计上并不完善，对于上述情况，会造成的野指针报错，从而，不推荐使用auto_ptr

模拟实现基本的auto_ptr功能

namespace why
{   //模拟实现auto_ptr
    template<class T>
    class auto_ptr
    {   
    public:
        auto_ptr(T* ptr=nullptr)
            :_ptr(ptr)
        {}
        T& operator*()
        {
            return *_ptr;
        }
        T& operator->()
        {
            return _ptr;
        }

        auto_ptr(const auto_ptr<T>& ptr)
            :_ptr(ptr._ptr)
        {
            delete ptr._ptr;
            //ptr._ptr = nullptr;
        }
        ~auto_ptr()
        {
            delete _ptr;
        }
    private:
        T* _ptr;
    };
}

unique_ptr

unique_ptr是在c++11之后推出的智能指针，除了不能赋值拷贝，和auto_ptr功能了类似

namespace why
{
    template<class T>
    class unique_ptr
    {
    public:
        unique_ptr(T* ptr=nullptr)
            :_ptr(ptr)
        {}

        T& operator*()
        {
            return *_ptr;
        }
        unique_ptr(const unique_ptr<T>& up) = delete;//防止赋值拷贝，以及赋值拷贝构造
        unique_ptr<T>& operator=(const unique_ptr<T>& up) = delete;
        T* operator->()
        {
            return _ptr;
        }
        ~unique_ptr()
        {
            delete _ptr;
        }
    private:
        T* _ptr;
    };
}
int main()
{
    why::unique_ptr<string> ptr1(new string("xxx"));
    //why::unique_ptr<string> ptr2;
    //ptr2 = ptr1;  //赋值拷贝
    // 
    auto ptr3 = ptr1;//赋值拷贝+构造=拷贝构造，编辑器优化直接调用拷贝构造
    //auto ptr2(ptr1);
    return 0;
}

shared_ptr

C++11推出的智能指针，其特点是可以多个指针对象共享一块资源（指向同一空间），是通过引用计数的方式来实现多个shared_ptr对象之间共享资源。

namespace why
{
    template<class T>
    class shared_ptr
    {
    public:
        shared_ptr(T* ptr=nullptr)
            :_ptr(ptr)
            ,_pnum(new int(1))//初始计数为1，表示有一个指针指向这一空间
        {
            cout << "构造函数的实现" << endl;
        }
        T& operator*()
        {
            return &_ptr;
        }
        T* operator->()
        {
            return _ptr;
        }
        shared_ptr(const shared_ptr<T>& sp)//拷贝构造函数
        {
            cout << "拷贝构造函数的实现" << endl;
            if (this != &sp)
            {
                _ptr = sp._ptr;
                _pnum = sp._pnum;
                ++(*_pnum);
            }
        }
        shared_ptr<T> operator=(const shared_ptr<T> sp)//赋值拷贝是先执行拷贝构造，然后再执行赋值
        {
            cout << "赋值拷贝的实现" << endl;
            if (this == &sp)
            {
                return *this;
            }
            if (--(*_pnum) == 0)
            {
                delete _ptr;
                delete _pnum;
            }
            _ptr = sp._ptr;
            _pnum = sp._pnum;
            ++(*_pnum);

            return *this;
        }
        ~shared_ptr()
        {
            if (--(*_pnum) == 0)//如果为0，表示直接释放即可，如果不为零，也会减去1
            {
                cout << "析构函数的实现" << endl;
                delete _ptr;
                delete _pnum;
            }
        }
        int getPcount()
        {
            return *_pnum;
        }
        
    private:
        T* _ptr;
        int* _pnum;//用来计数，记录指向同一地址的指针，有几个，防止多次对于同一地址进行释放空间，发生异常
    };
}

int main()
{
    why::shared_ptr<string> sp(new string("Xxx"));
    auto sp2(sp);
    why::shared_ptr<string> sp3;
    sp3 = sp2;
    cout << sp2.getPcount() << endl;//设置方法来获得此时共同管理的对象个数

    return 0;
}

shared_ptr的实现，使得可以多个指针共同访问同一地址，相对于unique_ptr区别就是能不能多个对象对于同一空间进行资源管理。

但是对于shared_ptr也存在缺点，可能会导致死循环（不能释放空间），如下代码所示

class node
{
public:
    //假如A类的成员变量中需要指针的存在，且需要多个对象能访问同一空间地址，选择shared_ptr
    shared_ptr<node> prev;
    shared_ptr<node> next;
};
int main()
{
    //如果此时我们想要满足实现类似于链表之间的关系
    shared_ptr<node> a(new node);
    auto b = a;
    a->next = b;
    b->prev = a;

    cout << b.get() << endl;
    cout << a.get() << endl;
    
    return 0;
}

为了解决shared_ptr指针循环引用的问题，引入weak_ptr

weak_ptr

weak_ptr拥有的功能和shared_ptr类似，只是不采取引用计数，即不会去管理指针的生命周期问题，只是单纯的去使用，访问该资源，不会去管理。

weak_ptr一般是配合shared_ptr来使用的一种智能指针，通过这一指针，我们可以解决shared_ptr循环引用的问题

class node
{
public:
    weak_ptr<node> _prev;//不参与管理，不会采取引用计数的方式，所以就算是指向下一个节点，也不会使得计数++
    weak_ptr<node> _next;
};

int main()
{
    shared_ptr<node> a;
    shared_ptr<node> b;
    a->_next = b;
    b->_prev = a;//此时，虽然互相指向，但是a和b的引用计数use_count都是1，即可以直接释放
    return 0;
}

weak_ptr还有很多其他的作用和功能，但是其主要是配合shared_ptr来使用

use_count 函数得到引用计数的数值

expired 函数判断当前weak_ptr指向的shared_ptr是否被销毁，返回类型是bool，判断依据是use_count==0是否成立

lock 函数是如果expired == true，表示weak_ptr管理的shared_ptr已经被销毁，返回nullptr，反之返回指向的shared_ptr

删除器

对于new申请的空间，我们可以通过delete进行直接删除，对于malloc、calloc、realloc等动态申请的空间，我们引入另一种概念，删除器

template<class T>
struct func {
public:
    void operator()(T* t)
    {
        cout << "free" << endl;
        free(t);
    }
};

template<class T>
struct arrdelete {
    void operator()(T* t)
    {
        cout << "delete" << endl;
        delete[] t;
    }
};
int main()
{
    func<string> f;
    arrdelete<string> a;
    //shared_ptr<string> sp1(new string("xxx"), f);
    shared_ptr<string> sp2(new string[10]{"xxx"}, a);//仿函数实现
    shared_ptr<string> sp3(new string[10]{ "Xxxx" }, [](string* ptr) {delete[] ptr; });//lambda函数实现
    return 0;
}

所以如果是对于malloc、calloc、realloc等动态申请空间的指针，我们对于其进行删除管理的时候，需要使用仿函数/lambda函数，lambda函数是最为方便的。

shared_ptr s(new string[10]);

这一种申请方式会编辑报错，需要设计删除器材，delete[]删除，或者是free函数删除(malloc、calloc、realloc函数申请的空间资源)，建议使用下面的方式来实现删除器

shared_ptr<string> s(new string[10], [](string* s) {delete[] s; });

shared_ptr<string> s((string*)malloc(4), [](string* s) {free(s); });

总结

智能指针的出现，在项目中具有重要意义，可以自动的控制对象的声明周期，合理使用智能指针就不会出现内存泄漏的问题，在平时练习c++的过程中对于智能指针的要求并不高，可以直接使用普通指针即可。

在智能指针中，auto_ptr已经被抛弃了（风险高），主要是使用c++11之后推出的三种指针，unqiue_ptr、shared_ptr、weak_ptr，进行对于管理动态申请的空间/对象，但是要注意的是对于malloc、calloc、realloc申请的空间要实现删除器，不然会导致运行报错。

//如果是内置类型，就不需要删除器的存在
shared_ptr<string*> s(new string*(nullptr));//如果泛型类型是指针，那么就不需要删除器的存在
shared_ptr<string> s(new string[10]);//对象s为string类型的指针，我们new出来10个类型为string的数组，将地址给s的_ptr,这一种情况就需要删除器的存在，以为T类型为string  进入析构函数为delete _ptr，不能删除数组地址，所以会运行报错

删除器的存在与否，决定于泛型中T的类型，析构函数为delete _ptr(T*_ptr) 是否能删除new出来或者malloc的空间

即delete _ptr是否能匹配

shared_ptr<string> s(new string[10]);
//string* _ptr   -> 构造函数 -> _ptr=new string[10];
//析构函数 -> delete _ptr ->delete 数组应该为delete[]_ptr 所以不能匹配，不能正确释放，即运行报错

//所以是否需要删除器，关键是T的类型和delete _ptr以及构造函数的参数（上文的new string[10]）