学步园

    每次创建类的新对象时，初始化指针并将引用计数置为1；

    当对象作为另一对象的副本而创建时，拷贝构造函数拷贝指针并增加与之相应的引用计数；

    对一个对象进行赋值时，赋值操作符减少左操作数所指对象的引用计数（如果引用计数为减至0，则删除对象），并增加右操作数所指对象的引用计数；这是因此左侧的指针指向了右侧指针所指向的对象，因此右指针所指向的对象的引用计数+1；

    调用析构函数时，构造函数减少引用计数（如果引用计数减至0，则删除基础对象）。

    实现智能指针有两种经典策略：一是引入辅助类，二是使用句柄类。我现在只会第一种，第二种留在以后研究；

直接上代码：

#include <iostream>

using namespace std;

class Point  //基础对象类，要做一个对Point类的智能指针
{
private:
	int x,y;
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;
	}
	~Point()
	{
		cout<<"调用析构函数~Point()"<<endl;
	}
};

class RefPtr //辅助类
{
private://该类的成员访问权限全部为private，因为不想让用户直接使用该类
	friend class SmartPtr;//定义智能指针类为友元，因为智能指针类需要直接操纵辅助类
	RefPtr(Point* ptr):p(ptr),count(1){}
	~RefPtr() {
		cout<<"调用析构函数~RefPtr()"<<endl;
		delete p;}

	int count;//引用计数
	Point* p;//基础对象指针
};

class SmartPtr//智能指针类
{
private:
	RefPtr* rp;//辅助类对象指针
public:
	SmartPtr(Point* ptr):rp(new RefPtr(ptr)){} //构造函数
	SmartPtr(const SmartPtr& sp):rp(sp.rp)//复制构造函数
	{
		++rp->count;
	}
	SmartPtr& operator=(const SmartPtr& rhs)//重载赋值操作符
	{
		
			++rhs.rp->count;//首先将右操作数引用计数加1
			if(--rp->count == 0) //左操作数减1
				delete rp;
			rp = rhs.rp;
			return *this;
	

	}

	~SmartPtr(){//析构函数

		if(--rp->count == 0)//当引用计数减为0的时候，删除辅助类对象指针，从而删除基础对象
		{
			cout<<"调用析构函数:~SmartPtr()"<<endl;
			delete rp;
		}
	}
	int getCount()
	{
		return rp->count;
	}
};

int main()
{
	Point* p1 = new Point(10,8);
	SmartPtr sp1(p1);//此时sp1.rp->count = 1
	cout<<"此时的引用计数为："<<sp1.getCount()<<endl;
	SmartPtr sp2(sp1);//首先将sp1.rp->count赋给sp2.rp->count,之后sp2.rp->count++,这时sp1,sp2的rp是指向同一个对象
	cout<<"此时sp1的引用计数为："<<sp1.getCount()<<endl;//sp1,sp2指向同一个对象，说明这个对象被两个指针所拥有，引用计数为2
	cout<<"此时sp2的引用计数为："<<sp2.getCount()<<endl;
	cout<<"************************"<<endl;
	Point* p2 = new Point(5,6);
	SmartPtr sp3(p2);//此时sp3.rp->count = 1  sp3所指的是完全的另外一个内存对象，它的引用计数为1
	cout<<"此时sp1的引用计数为："<<sp1.getCount()<<endl;//2
	cout<<"此时sp2的引用计数为："<<sp2.getCount()<<endl;//2
	cout<<"此时sp3的引用计数为："<<sp3.getCount()<<endl;//1
	cout<<"************************"<<endl;
	sp3 = sp1;//首先sp1的引用计数加1，因为多了一个sp3指向它的对象，所以sp1的引用计数此时为3
	//而，sp3引用计数此时减1，变成了0，此时 P2这个内存没有人占用，所以此时释放，这个时候调用析构函数删除P2
	cout<<"此时sp1的引用计数为："<<sp1.getCount()<<endl;
	cout<<"此时sp2的引用计数为："<<sp2.getCount()<<endl;
	cout<<"此时sp3的引用计数为："<<sp3.getCount()<<endl;

	
	
	return 0;
}
/*
下面是输出的代码：
此时的引用计数为：1
此时sp1的引用计数为：2
此时sp2的引用计数为：2
************************
此时sp1的引用计数为：2
此时sp2的引用计数为：2
此时sp3的引用计数为：1
************************
调用析构函数~RefPtr()
调用析构函数~Point()
此时sp1的引用计数为：3
此时sp2的引用计数为：3
此时sp3的引用计数为：3
调用析构函数:~SmartPtr()
调用析构函数~RefPtr()
调用析构函数~Point()

2014年9月16日16:38:12
*/

根据我上面的代码运行仔细研究，会体会到智能指针的引用计数的变化。

使用该方式的内存结构图如下：

运行代码加上这个内存结构图，相信可以很好的理解智能指针。