【C++】智能指针

一、简介

为什么会有智能指针这个东西，智能指针又是什么东西。

由于 C++ 语言没有自动内存回收机制，程序员每次 new 出来的内存都要手动 delete。程序员忘记 delete，流程太复杂，最终导致没有 delete，异常导致程序过早退出，没有执行 delete 的情况并不罕见。那么就有了智能指针这个东西。

智能指针就是基于RAII的要求使用模板类，自动化地管理动态资源的释放（不管理资源的创建），智能指针看上去是指针，实际上是赋予了定义的对象。智能指针(smart pointer)是存储指向动态分配（堆）对象指针的类，用于生存期控制，能够确保自动正确的销毁动态分配的对象，防止内存泄露。

RAII（Resource Acquisition Is Initialization）是一种利用对象生命周期来控制程序资源（如内存、文件句柄、网络连接、互斥量等等）的简单技术。

二、智能指针

C++STL提供了4种智能指针，包括auto_ptr、unique_ptr(scoped_ptr)、shared_ptr和weak_ptr。

(1)auto_ptr

独占所有权，所有权转移

auto_ptr版本的智能指针采用的是管理权转移的方法，即由a构造出b对象之后，a对象置为NULL，即之后不能再访问a对象，只有b一个对象维护该空间。

模板auto_ptr是C++98提供的解决方案，C+11已将将其摒弃。，不推荐使用。

旧版本的auto_ptr,用bool值控制
旧库使用拥有者会导致野指针。

template<class T>
class AutoPtr
{
public:
    AutoPtr(T *p = NULL)
        :_Ptr(p)
        , _owner(false)
    {
        if (_Ptr != NULL)
        {
            _owner = true;
        }
    }
    ~AutoPtr()
    {
        if (_owner)
        {
            delete _Ptr;
            _Ptr = NULL;
        }
    }
    AutoPtr(AutoPtr<T>& ap)
        :_Ptr(ap._Ptr)
        , _owner(ap._owner)
    {
        ap._owner = false;
    }
    AutoPtr& operator=(AutoPtr<T>& ap)
    {
        if (_Ptr != ap._Ptr) // 这里不要用this和ap 判断是否为自我赋值，
        {
            if (_owner)
                delete _Ptr;

            _Ptr = ap._Ptr;
            _owner = ap._owner; //_owner = ture;
            ap._owner = false;
        }

        return *this;
    }
    T& operator*()
    {
        return *_Ptr;
    }
    T* operator->()
    {
        if (_owner)
        {
            return _Ptr;
        }
        return NULL;
    }
    T* Get()
    {
        if (_owner)
        {
            return _Ptr;
        }
        return NULL;
    }
private:
    T* _Ptr;
    bool _owner;
};

新版本的auto_ptr

template<typename T>
class AutoPtrNew
{
public:
    AutoPtrNew(T *p = NULL)
        :_Ptr(p)
    {
    }
    ~AutoPtrNew()
    {
        if (NULL != _Ptr)
        {
            delete _Ptr;
            _Ptr = NULL;
        }
    }
    AutoPtrNew(AutoPtrNew<T>& ap)
        :_Ptr(ap._Ptr)
    {
        ap._Ptr = NULL;
    }
    AutoPtrNew& operator=(AutoPtrNew<T>& ap)
        // 思路 ：判断是不是自我赋值；然后判断左值是不是空，不空的话释左值；
        //        右值赋值给左值，右值置空
    {
        if (_Ptr != ap._Ptr) // 这里不要用this和ap 判断是否为自我赋值，
        {
            if (NULL != _Ptr)
            {
                delete _Ptr;
            }
            _Ptr = ap._Ptr;
            ap._Ptr = NULL;
        }
        return *this;
    }
    T& operator*()
    {
        return *_Ptr;
    }
    T* operator->()
    {
        return _Ptr;
    }
    T* Get()
    {
        return _Ptr;
    }
private:
    T* _Ptr;
};

(2) scoped_ptr(unique_ptr)
独占所有权，防拷贝

scoped_ptr的实现原理是防止对象间的拷贝和赋值，即将拷贝构造和赋值运算符重载放入保护或私有的访问限定符内，只声明不定义防止他人在类外拷贝。简单粗暴地解决了auto_ptr的缺点，提高了代码的安全性，但是导致功能不完整。

unique_ptr 是 C++11 标识， ScopedPtr 是 boost库提供 还有ScopedAarray。

template<class T>
class ScopedPtr
{
public:
    ScopedPtr(T * p = NULL)
        :_Ptr(p)
    {
    }
    ~ScopedPtr()
    {
        if (NULL != _Ptr)
        {
            delete _Ptr;
            _Ptr = NULL;
        }
    }
    T& operator*()
    {
        return *_Ptr;
    }
    T* operator->()
    {
        return _Ptr;
    }
private:
    ScopedPtr(ScopedPtr<T>& sp);//只声明不实现，并且声明为私有，防止其他人实现并调用  
    ScopedPtr<T>& operator=(ScopedPtr<T>& sp);
private:
    T* _Ptr;
};

(3)shared_ptr

shared_ptr的实现原理是通过引用计数(int *count)来实现，拷贝或赋值时将引用计数加1，析构时只有当引用计数减到0才释放空间，否则只需将引用计数减1即可。

template<class T>
class SharedPtr
{
public:
    SharedPtr(T* p = NULL)
        :_Ptr(p)
        , _pCount(NULL)
    {
        if (NULL != _Ptr)
        {
            _pCount = new int(1);
        }
    }
    ~SharedPtr()
        //要判断计数器指针是否为空
    {
        if (NULL != _pCount && --(*_pCount) == 0)
        {
            delete _Ptr;
            _Ptr = NULL;
            delete _pCount;
            _pCount = NULL;
        }
    }
    SharedPtr(SharedPtr<T>& sp)
        :_Ptr(sp._Ptr)
        , _pCount(sp._pCount)
    {
        if (NULL != _pCount)
            ++(*_pCount);
    }
    SharedPtr<T>& operator=(SharedPtr<T>& sp)
        //思路：判断自我赋值 左值_Ptr分三种情况 空 1个使用  多个使用
    {
        if (_Ptr != sp._Ptr)
        {
            if (NULL == _Ptr) //空
            {
                _Ptr = sp._Ptr;
                _pCount = sp._pCount;
            }
            else
            {
                if (--(*_pCount) == 0) //1
                {
                    delete _Ptr;
                    delete _pCount;
                }
                _Ptr = sp._Ptr;
                _pCount = sp._pCount;
            }
            if (NULL != _pCount)
                (*_pCount)++;
        }
        return *this;
    }
    int UserCount()
    {
        return *_pCount;
    }
    T* operator->()
    {
        return _Ptr;
    }
    T& operator*()
    {
        return *_Ptr;
    }
private:
    T* _Ptr;
    int* _pCount;
};

循环引用的问题。

就是指两个对象进行相互引用，造成相互制约的关系，导致智能指针不能释放的问题。

测试代码

//循环引用
#include <boost/shared_ptr.hpp>
#include <boost/weak_ptr.hpp>
using namespace boost;
struct ListNode
{
    shared_ptr<ListNode > _prev;
    shared_ptr<ListNode > _next;
    //weak_ptr<ListNode > _prev;
    //weak_ptr<ListNode > _next;
    ~ListNode()
    {
        cout << "~ListNode()" << endl;
    }
};

void Test()
{
    // 循环引用问题
    shared_ptr <ListNode > p1(new ListNode());
    shared_ptr <ListNode > p2(new ListNode());
    cout << "p1->Count:" << p1.use_count() << endl;
    cout << "p2->Count:" << p2.use_count() << endl;
    // p1节点的_next指向 p2节点
    p1->_next = p2;
    // p2节点的_prev指向 p1节点
    p2->_prev = p1;
    cout << "p1->Count:" << p1.use_count() << endl; //2
    cout << "p2->Count:" << p2.use_count() << endl; //2

}

通过上面的代码结合图可以知道，p1指针的count =2，（一个是自己本身对象，另一个是p2中的prev指向p1对象），同样的p2指针的count = 2；

这样当函数运行完结束的时候，p2先释放，count = 1，没有被释放，p1再释放，count = 1，没有被释放；而且，p1对象的释放是由p2的prev指向p1的，p1的释放，需要等待p2的释放，才能完成p1的释放，同理p2的释放也需要p1的释放，才能完成自己的p2的释放。

这样的话，它们互相等待，悲剧就发生了，两个都无法释放，

循环引用–使用一个弱引用智能指针(weak_ptr)来打破循环引用（weak_ptr不增加引用计数）

weak_ptr是一个弱引用，只引用，不计数。如果一块内存被shared_ptr和weak_ptr同时引用，当所有shared_ptr析构了之后，不管还有没有weak_ptr引用该内存，内存也会被释放。所以weak_ptr不保证它指向的内存一定是有效的，在使用之前需要检查weak_ptr是否为空指针。

weak_ptr是一种不控制所指向对象生存期的智能指针，它指向一个shared_ptr管理的对象。将一个weak_ptr绑定到shared_ptr不会改变shared_ptr的引用计数。一旦最后一个指向对象的shared_ptr被销毁，对象就会被释放，即使有weak_ptr指向对象，对象还是会被释放。当我们创建一个weak_ptr时，要用一个shared_ptr来初始化它。
解决循环引用。

template<typename T>
struct ListNode{
    T _value;
    weak_ptr<ListNode> _prev;
    weak_ptr<ListNode> _next;

    ListNode(const T & value)
        :_value(value)
        ,_prev(NULL)
        ,_next(NULL){}

    ~ListNode(){
        std::cout<<"~ListNode()"<<std::endl;
    }
};
void TestWeekPtr(){
    std::shared_ptr<ListNode<int>> sp1(new ListNode<int>(10));
    std::shared_ptr<ListNode<int>> sp2(new ListNode<int>(20));
    sp1->_next = sp2;
    sp2->_prev = sp1;

    std::cout<<sp1.use_count()<<std::endl;
    std::cout<<sp2.use_count()<<std::endl;
}

定制删除器

由于每种指针释放资源的方式不同，比如数组用delete[]释放资源，文件用fclose关闭等。我们需要针对不同的资源选择合适的释放方式，定制删除器便是通过仿函数来完成该功能。

#include<memory>
#include<iostream>
using namespace std;


class Fclose1
{
public:
    void operator () (FILE *& fp)
    {

        if (NULL != fp)
        {
            fclose(fp);
            fp = NULL;
        }
    }
};
void Fclose(FILE* fp)
{
    if (NULL != fp)
    {
        fclose(fp);
        fp = NULL;
    }
}
void FunTest()
{
    FILE* fp = fopen("1.txt", "w");

    shared_ptr<FILE> sp1(fp, Fclose1());//仿函数
    shared_ptr<FILE> sp2(fp, Fclose);//函数指针
}