探索智能指针

代码如下，不过这个智能指针有个缺陷，就是只能指向在堆中创建的对象，加以修改后可以改成只能指向在栈中创建的对象，但是无法兼顾两种情况（如果要兼顾两种情况，则智能指针只能指向对象的新建副本，这又失去了指针原有的含义，so...）

#include <iostream>
using namespace std;

class Object//能被智能指针所指的类
{
public:
	void ShowAddress()
	{
		cout << "对象的地址为"<<this <<endl ;
	}
	
	~Object()
	{
		cout <<"地址为:" <<this <<"的对象释放完毕" <<endl;
	}

	void SayHello()
	{
		cout <<"Hello world!" <<endl;
	}
};

class CPtr//智能代理指针
{
private:
	Object* mRealPtr;
	int mUse;
public:
	friend class SmartPoiter;
	CPtr(Object* ptr)
	{
		mRealPtr = ptr;//修改词句，让mRealPtr指向对象的副本，则可以兼顾既可以指向堆，也可以指向栈中的对象
		mUse = 1;
	}

	~CPtr()
	{
		cout << "对象引用次数为为0了，将导致释放智能代理指针，此过程也将导致对象释放" << endl;
		delete mRealPtr;//去掉词句，可以指向在栈中分配的对象
	}
};

class SmartPoiter//智能指针类
{
private:
	CPtr* mPtr;
public:
	SmartPoiter(Object * p)
	{
		mPtr = new CPtr(p);
	}

	SmartPoiter(SmartPoiter& o)
	{
		if(this != &o)
		{
			mPtr = o.mPtr;
			++(mPtr->mUse);
		}
	}

	SmartPoiter& operator =(SmartPoiter& o)
	{
		if(this != &o)
		{
			mPtr = o.mPtr;
			++(mPtr->mUse);
		}
		return *this;
	}

	~SmartPoiter()
	{
		cout << "析构智能指针对象,释放后引用对象的引用计数为"<< --(mPtr->mUse) << endl;

		if(mPtr->mUse == 0)
			delete mPtr;
	}

	void ShowAddress()
	{
		cout <<"这个智能指针对象指向的对象的地址为"<< mPtr->mRealPtr <<"  这个引用对象的使用计数为" << mPtr->mUse << endl;
	}

	//使其支持指针操作
	Object& operator *()//重载*，以模拟指针操作
	{
		return *(mPtr->mRealPtr);
	}

	Object* operator->()//重载->，以模拟指针操作
	{
		return mPtr->mRealPtr;
	}
};

int main()
{
	Object* ob = new Object();
	ob ->ShowAddress();

	SmartPoiter A(ob);
	A.ShowAddress();
	SmartPoiter B(A);
	B.ShowAddress();
	SmartPoiter C = A;
	C.ShowAddress();

	A = A;//测试自我赋值问题

	A.ShowAddress();
	B.ShowAddress();
	C.ShowAddress();

	(*A).ShowAddress();
	B->ShowAddress();
	B->SayHello();
	return 1;
}

运行结果如下