引用计数

引用计数，使用浅拷贝，同时也不会错误的释放了内存，引用数为0我再delete掉
注意，引用计数部分，应该做到不同对象都能访问到，放到堆内存，
一个成员变量,指向堆里面一块空间，这块地方用于管理引用数，
浅拷贝的时候，不同对象只需要拷贝成员变量，也就是这些指针变量指向同一个地方，
都指向这块 管理引用计数的 地方。

class RefCount
{
public:
	RefCount() :m_count(0) {}
public:
	unsigned AddRef() { return InterlockedIncrement(&m_count); }
	unsigned Release() { return InterlockedDecrement(&m_count); }
	void Reset() { m_count = 0; }
private:
	unsigned long m_count;
};

class Rect
{
public:
	Rect()
	{
		p = new int(100);
		_refcount = new RefCount();
		_refcount->AddRef();
	}//int型指针 指向一个整形变量 值是100  不是p = new int[100];切记

	//Rect(const Rect& r) 
	//{ 
	//	p = new int;	//p指向 一块新的整形变量内存
	//	*p = *(r.p);	//p指向的整形变量 内容 赋值成 r的p指针指向的 内容  这就是深拷贝了  否则 p = r.p 就是浅拷贝
	//					//	p = r.p			p与r.p	   同一个地址
	//					//	*p = *(r.p)		p与r.p指向的不同整形变量 里面内容一样
	//	width = r.width;
	//	height = r.height;
	//}
	//Rect& operator=(const Rect& r)
	//{
	//	p = new int;
	//	*p = *(r.p);
	//	width = r.width;
	//	height = r.height;
	//}
	//要么禁用 默认拷贝构造函数 要么重写 实现深拷贝 
	//要么浅拷贝 同时使用引用计数 引用数为0再delete
	Rect(const Rect& r)
	{
		width = r.width;
		height = r.height;
		_refcount = r._refcount;
		p = r.p;
		_refcount->AddRef();		
	}
	Rect& operator=(const Rect& r)
	{
		width = r.width;
		height = r.height;
		_refcount = r._refcount;
		p = r.p;
		_refcount->AddRef();
	}
	void setWH(int w, int h)
	{
		width = w;
		height = h;
	}
	~Rect() 
	{
		if(_refcount->Release()==0)
			delete p; 
	}
private:
	//DISALLOW_COPY_AND_ASSIGN(Rect); //声明为私有成员 禁掉拷贝构造函数
private:
	int* p;
	int width;
	int height;
	RefCount* _refcount;
};
int main()
{
        Rect r1;
	Rect r2 = r1;
	Rect r3(r1);
}