C++智能指针简单实现

参考:
C++ 引用计数技术及智能指针的简单实现 - melonstreet - 博客园
c++ primer 5th 12.1

智能指针是什么

简单来说，智能指针是一个管理内存的类，它对普通指针进行封装，使智能指针类对象具有普通指针类型一样的操作。具体而言，拷贝对象时，副本和原对象都指向同一存储区域，如果通过一个副本改变其所指的值，则通过另一对象访问的值也会改变。所不同的是，智能指针能够对内存进行进行自动管理，避免出现悬垂指针等情况。

普通指针存在的问题

多个指针指向同一个基础对象时，如果某个指针delete了该基础对象，对这个指针来说它是明确了它所指的对象被释放掉了，所以它不会再对所指对象进行操作，但是对于剩下的其他指针来说呢？它们还傻傻地指向已经被删除的基础对象并随时准备对它进行操作。于是悬垂指针就形成了，程序崩溃也“指日可待”。我们通过代码+图来来探求悬垂指针的解决方法。

#include <iostream>
using namespace std;

int main(){
    int *ptr1 = new int(1);
    int *ptr2 = ptr1;
    int *ptr3 = ptr2;
    cout << *ptr1 << endl;//1
    cout << *ptr2 << endl;//1
    cout << *ptr3 << endl;//1
    delete ptr1;
    cout << *ptr2 << endl;//0
    return 0;
}

运行结果是输出ptr2时并不是期待的1，因为1已经被删除了。这个过程是这样的：



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


那么何时才可以删除基础对象呢？当然是只有一个指针指向基础对象的时候，这时通过该指针就可以大大方方地把基础对象删除了。

什么是引用计数?

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

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

智能指针实现

智能指针的实现策略有两种：辅助类与句柄类。这里介绍辅助类的实现方法。

基础对象类

首先，我们来定义一个基础对象类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;
};

辅助类

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

class U_Ptr{
private:
	friend class SmartPtr;      
	U_Ptr(Point *ptr) : p(ptr), count(1) { }//创建的时候count初始化为1
	~U_Ptr() { delete p; }
	Point *p;
    int count;                                                         
};

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

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

• 当创建类的新对象时，初始化指针，并将引用计数设置为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;//首先将右操作数引用计数加1，
        if(--rp->count == 0)    delete rp;//然后将引用计数减1，可以应对自赋值
        rp = rhs.rp;
        return *this;
    } 
    ~SmartPtr(){//析构函数
        if(--rp->count == 0)    delete rp;//当引用计数减为0时，删除辅助类对象指针，从而删除基础对象
        else cout << "还有 " << rp->count << " 个指针指向基础对象" << endl;
    }

private:
    U_Ptr *rp;//辅助类对象指针
};

智能指针类的使用与测试

#include <iostream>
using namespace std;

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;
};

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

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;//首先将右操作数引用计数加1，
        if(--rp->count == 0)    delete rp;//然后将引用计数减1，可以应对自赋值
        rp = rhs.rp;
        return *this;
    } 
    ~SmartPtr(){//析构函数
        if(--rp->count == 0)    delete rp;//当引用计数减为0时，删除辅助类对象指针，从而删除基础对象
        else cout << "还有 " << rp->count << " 个指针指向基础对象" << endl;
    }

private:
    U_Ptr *rp;//辅助类对象指针
};

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;//未定义的值

    return 0;
}

输出：

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

智能指针类的改进一

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

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;//首先将右操作数引用计数加1，
        if(--rp->count == 0)    delete rp;//然后将引用计数减1，可以应对自赋值
        rp = rhs.rp;
        return *this;
    } 
    ~SmartPtr(){//析构函数
        if(--rp->count == 0)    delete rp;//当引用计数减为0时，删除辅助类对象指针，从而删除基础对象
        else cout << "还有 " << rp->count << " 个指针指向基础对象" << endl;
    }
    Point& operator*() const {//重载*操作符  
        return *(rp->p);
    }
    Point* operator->() const {//重载->操作符  
        return rp->p;
    }

private:
    U_Ptr *rp;//辅助类对象指针
};

那么就可以实现：

        SmartPtr sptr1(pa);//此时计数count=1
        cout << sptr1->getX() << endl;
        cout << (*sptr1).getX() << endl;

智能指针改进二

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

#include <iostream>
using namespace std;

//模板类作为友元时要先有声明
template <class T>
class SmartPtr;

template <class T>
class U_Ptr{
private://该类成员访问权限全部为private，因为不想让用户直接使用该类
	friend class SmartPtr<T>;//定义智能指针类为友元，因为智能指针类需要直接操纵辅助类
	U_Ptr(T *ptr) : p(ptr), count(1) { }
	~U_Ptr() { delete p; }
	T *p;//基础对象指针
    int count;//引用计数                                            
};

template <class T>
class SmartPtr{//智能指针类
public:
    SmartPtr(T *ptr) : rp(new U_Ptr<T>(ptr)) {}//构造函数
    SmartPtr(const SmartPtr &sp) : rp(sp.rp) { ++rp->count;}//复制构造函数
    SmartPtr& operator=(const SmartPtr& rhs){//重载赋值操作符
        ++rhs.rp->count;//首先将右操作数引用计数加1，
        if(--rp->count == 0)    delete rp;//然后将引用计数减1，可以应对自赋值
        rp = rhs.rp;
        return *this;
    } 
    T& operator*() const {//重载*操作符  
        return *(rp->p);
    }
    T* operator->() const {//重载->操作符  
        return rp->p;
    }
    ~SmartPtr(){//析构函数
        if(--rp->count == 0)    delete rp;//当引用计数减为0时，删除辅助类对象指针，从而删除基础对象
        else cout << "还有 " << rp->count << " 个指针指向基础对象" << endl;
    }

private:
    U_Ptr<T> *rp;//辅助类对象指针
};

int main(){
     int *i = new int(2);
    //定义三个智能指针类对象，对象都指向基础类对象pa
	//使用花括号控制三个指针指针的生命期，观察计数的变化
    {
        SmartPtr<int> ptr1(i);//此时计数count=1
        {
            SmartPtr<int> ptr2(ptr1);//调用拷贝构造函数，此时计数为count=2
            {
                SmartPtr<int> ptr3 = ptr1;//调用拷贝赋值运算符，此时计数为conut=3
                cout << *ptr1 << endl;
                *ptr1 = 20;
                cout << *ptr2 << endl;
            }//此时count=2
        }//此时count=1
    }//此时count=0

    return 0;
}

输出：