C++ 引用计数技术及智能指针的简单实现

时间 2019-11-06

标签 c++ 引用计数技术智能指针简单实现栏目 C&C++ 繁體版

原文原文链接

文章也发布在腾讯云+社区程序员

一直以来都对智能指针只知其一;不知其二，看C++Primer中也讲的不够清晰明白（大概是我功力不够吧）。最近花了点时间认真看了智能指针，特意来写这篇文章。安全

1.智能指针是什么

简单来讲，智能指针是一个类，它对普通指针进行封装，使智能指针类对象具备普通指针类型同样的操做。具体而言，复制对象时，副本和原对象都指向同一存储区域，若是经过一个副本改变其所指的值，则经过另外一对象访问的值也会改变.所不一样的是，智能指针可以对内存进行进行自动管理，避免出现悬垂指针等状况。bash

2.普通指针存在的问题

C语言、C++语言没有自动内存回收机制，关于内存的操做的安全性依赖于程序员的自觉。程序员每次new出来的内存块都须要本身使用delete进行释放，流程复杂可能会致使忘记释放内存而形成内存泄漏。而智能指针也致力于解决这种问题，使程序员专一于指针的使用而把内存管理交给智能指针。函数

咱们先来看看普通指针的悬垂指针问题。当有多个指针指向同一个基础对象时，若是某个指针delete了该基础对象，对这个指针来讲它是明确了它所指的对象被释放掉了，因此它不会再对所指对象进行操做，可是对于剩下的其余指针来讲呢？它们还傻傻地指向已经被删除的基础对象并随时准备对它进行操做。因而悬垂指针就造成了，程序崩溃也“指日可待”。咱们经过代码+图来来探求悬垂指针的解决方法。测试

int * ptr1 = new int (1);
        int * ptr2 = ptr1;
        int * ptr3 = prt2;
        
        cout << *ptr1 << endl;
        cout << *ptr2 << endl;
        cout << *ptr3 << endl;

        delete ptr1;

        cout << *ptr2 << endl;

代码简单就不啰嗦解释了。运行结果是输出ptr2时并非期待的1，由于1已经被删除了。这个过程是这样的：
this

从图能够看出，错误的产生来自于ptr1的”无知“：它并不知道还有其余指针共享着它指向的对象。若是有个办法让ptr1知道，除了它本身外还有两个指针指向基础对象，而它不该该删除基础对象，那么悬垂指针的问题就得以解决了。以下图：
设计

那么什么时候才能够删除基础对象呢？固然是只有一个指针指向基础对象的时候，这时经过该指针就能够大大方方地把基础对象删除了。指针

3.什么是引用计数

如何来让指针知道还有其余指针的存在呢？这个时候咱们该引入引用计数的概念了。引用计数是这样一个技巧，它容许有多个相同值的对象共享这个值的实现。引用计数的使用常有两个目的：code

简化跟踪堆中（也即C++中new出来的）的对象的过程。一旦一个对象经过调用new被分配出来，记录谁拥有这个对象是很重要的，由于其全部者要负责对它进行delete。可是对象全部者能够有多个，且全部权可以被传递，这就使得内存跟踪变得困难。引用计数能够跟踪对象全部权，并可以自动销毁对象。能够说引用计数是个简单的垃圾回收体系。这也是本文的讨论重点。
节省内存，提升程序运行效率。如何不少对象有相同的值，为这多个相同的值存储多个副本是很浪费空间的，因此最好作法是让左右对象都共享同一个值的实现。C++标准库中string类采起一种称为”写时复制“的技术，使得只有当字符串被修改的时候才建立各自的拷贝，不然可能（标准库容许使用但没强制要求）采用引用计数技术来管理共享对象的多个对象。这不是本文的讨论范围。

4.智能指针实现

了解了引用计数，咱们可使用它来写咱们的智能指针类了。智能指针的实现策略有两种：辅助类与句柄类。这里介绍辅助类的实现方法。对象

4.1.基础对象类

首先，咱们来定义一个基础对象类Point类，为了方便后面咱们验证智能指针是否有效，咱们为Point类建立以下接口：

class Point                                       
{
public:
    Point(int xVal = 0, int yVal = 0) :x(xVal), y(yVal) { }
    int getX() const { return x; }
    int getY() const { return y; }
    void setX(int xVal) { x = xVal; }
    void setY(int yVal) { y = yVal; }

private:
    int x, y;

};

4.2.辅助类

在建立智能指针类以前，咱们先建立一个辅助类。这个类的全部成员皆为私有类型，由于它不被普通用户所使用。为了只为智能指针使用，还须要把智能指针类声明为辅助类的友元。这个辅助类含有两个数据成员：计数count与基础对象指针。也即辅助类用以封装使用计数与基础对象指针。

class U_Ptr                                  
{
private:
    
    friend class SmartPtr;      
    U_Ptr(Point *ptr) :p(ptr), count(1) { }
    ~U_Ptr() { delete p; }
    
    int count;   
    Point *p;                                                      
};

4.3.为基础对象类实现智能指针类

引用计数是实现智能指针的一种通用方法。智能指针将一个计数器与类指向的对象相关联，引用计数跟踪共有多少个类对象共享同一指针。它的具体作法以下：

当建立类的新对象时，初始化指针，并将引用计数设置为1
当对象做为另外一个对象的副本时，复制构造函数复制副本指针，并增长与指针相应的引用计数（加1）
使用赋值操做符对一个对象进行赋值时，处理复杂一点：先使左操做数的指针的引用计数减1（为什么减1：由于指针已经指向别的地方），若是减1后引用计数为0，则释放指针所指对象内存。而后增长右操做数所指对象的引用计数（为什么增长：由于此时作操做数指向对象即右操做数指向对象）。
析构函数：调用析构函数时，析构函数先使引用计数减1，若是减至0则delete对象。

作好前面的准备后，咱们能够来为基础对象类Point书写一个智能指针类了。根据引用计数实现关键点，咱们能够写出咱们的智能指针类以下：

class SmartPtr
{
public:
    SmartPtr(Point *ptr) :rp(new U_Ptr(ptr)) { }    
    
    SmartPtr(const SmartPtr &sp) :rp(sp.rp) { ++rp->count; }
      
    SmartPtr& operator=(const SmartPtr& rhs) {    
        ++rhs.rp->count;    
        if (--rp->count == 0)    
            delete rp;
        rp = rhs.rp;
        return *this;
    }
    
    ~SmartPtr() {       
        if (--rp->count == 0)   
            delete rp;
        else 
        cout << "还有" << rp->count << "个指针指向基础对象" << endl;
    }
    
private:
        U_Ptr *rp;  
};

4.4.智能指针类的使用与测试

至此，咱们的智能指针类就完成了，咱们能够来看看如何使用

int main()
{
    //定义一个基础对象类指针
    Point *pa = new Point(10, 20);

    //定义三个智能指针类对象，对象都指向基础类对象pa
    //使用花括号控制三个指针指针的生命期，观察计数的变化

    {
        SmartPtr sptr1(pa);//此时计数count=1
        {
            SmartPtr sptr2(sptr1); //调用复制构造函数，此时计数为count=2
            {
                SmartPtr sptr3=sptr1; //调用赋值操做符，此时计数为conut=3
            }
            //此时count=2
        }
        //此时count=1；
    }
    //此时count=0；pa对象被delete掉

    cout << pa->getX ()<< endl;

    system("pause");
    return 0;
}

来看看运行结果咯：

还有2个指针指向基础对象
还有1个指针指向基础对象
-17891602
请按任意键继续. . .

如期，在离开大括号后，共享基础对象的指针从3->2->1->0变换，最后计数为0时，pa对象被delete，此时使用getX（）已经获取不到原来的值。

5.智能指针类的改进一

虽然咱们的SmartPtr类称为智能指针，但它目前并不能像真正的指针那样有->、*等操做符，为了使它看起来更像一个指针，咱们来为它重载这些操做符。代码以下所示：

{
public:
    SmartPtr(Point *ptr) :rp(new U_Ptr(ptr)) { }    
    
    SmartPtr(const SmartPtr &sp) :rp(sp.rp) { ++rp->count; }
      
    SmartPtr& operator=(const SmartPtr& rhs) {    
        ++rhs.rp->count;    
        if (--rp->count == 0)    
            delete rp;
        rp = rhs.rp;
        return *this;
    }
    
    ~SmartPtr() {       
        if (--rp->count == 0)   
            delete rp;
        else 
        cout << "还有" << rp->count << "个指针指向基础对象" << endl;
    }
    

    Point & operator *()        //重载*操做符  
    {
        return *(rp->p);
    }
    Point* operator ->()       //重载->操做符  
    {
        return rp->p;
    }
    
private:
    U_Ptr *rp;  
};

而后咱们能够像指针般使用智能指针类

Point *pa = new Point(10, 20);
    SmartPtr sptr1(pa);
    //像指针般使用
    cout<<sptr1->getX();

6.智能指针改进二

目前这个智能指针智能用于管理Point类的基础对象，若是此时定义了个矩阵的基础对象类，那不是还得从新写一个属于矩阵类的智能指针类吗？可是矩阵类的智能指针类设计思想和Point类同样啊，就不能借用吗？答案固然是能，那就是使用模板技术。为了使咱们的智能指针适用于更多的基础对象类，咱们有必要把智能指针类经过模板来实现。这里贴上上面的智能指针类的模板版：

//模板类做为友元时要先有声明
    template <typename T>
    class SmartPtr;
    
    template <typename T>
    class U_Ptr     //辅助类
    {
    private:
        //该类成员访问权限所有为private，由于不想让用户直接使用该类
        friend class SmartPtr<T>;      //定义智能指针类为友元，由于智能指针类须要直接操纵辅助类
    
        //构造函数的参数为基础对象的指针
        U_Ptr(T *ptr) :p(ptr), count(1) { }
    
        //析构函数
        ~U_Ptr() { delete p; }
        //引用计数
        int count;   
    
        //基础对象指针
        T *p;                                                      
    };
    
    template <typename T>
    class SmartPtr   //智能指针类
    {
    public:
        SmartPtr(T *ptr) :rp(new U_Ptr<T>(ptr)) { }      //构造函数
        SmartPtr(const SmartPtr<T> &sp) :rp(sp.rp) { ++rp->count; }  //复制构造函数
        SmartPtr& operator=(const SmartPtr<T>& rhs) {    //重载赋值操做符
            ++rhs.rp->count;     //首先将右操做数引用计数加1，
            if (--rp->count == 0)     //而后将引用计数减1，能够应对自赋值
                delete rp;
            rp = rhs.rp;
            return *this;
        }
    
        T & operator *()        //重载*操做符  
        {
            return *(rp->p);
        }
        T* operator ->()       //重载->操做符  
        {
            return rp->p;
        }
    
    
        ~SmartPtr() {        //析构函数
            if (--rp->count == 0)    //当引用计数减为0时，删除辅助类对象指针，从而删除基础对象
                delete rp;
            else 
            cout << "还有" << rp->count << "个指针指向基础对象" << endl;
        }
    private:
        U_Ptr<T> *rp;  //辅助类对象指针
    };

好啦，如今咱们可以使用这个智能指针类对象来共享其余类型的基础对象啦，好比int：

int main()
{
    int *i = new int(2);
    {
        SmartPtr<int> ptr1(i);
        {
            SmartPtr<int> ptr2(ptr1);
            {
                SmartPtr<int> ptr3 = ptr2;

                cout << *ptr1 << endl;
                *ptr1 = 20;
                cout << *ptr2 << endl;

            }
        }
    }
    system("pause");
    return 0;
}

运行结果如期所愿，SmartPtr类管理起int类型来了：

2
        20
        还有2个指针指向基础对象
        还有1个指针指向基础对象
        请按任意键继续. . .