一个简单的C++智能指针的实现

一个简的C++的智能指针的实现

C++在堆上分配的内存需要分配者自己释放，但是有时分配者由于某种情况忘记释放，此时会造成内存泄漏，因此实现了一个简单的智能指针。

// 引用计数类，负责管理动态分配的内存的使用者数量
class Reference
{
public:
	Reference()
		:m_count(0)
	{

	}
	~Reference(){}

	// 自增
	int Add()
	{
		printf("add\n");
		return ++m_count;
	}

	// 自减
	int Release()
	{
		printf("release\n");
		return --m_count;
	}

private:
	int m_count;
};

// 动态分配的内存包装模板类，负责对动态分配的内存进行操作
template<typename T>
class SmartP
{
public:
	SmartP(T *p);
	SmartP(SmartP &p);
	~SmartP();
	SmartP &operator =(SmartP &p);
	T *operator ->();

	T *Get()
	{
		return m_tP;
	}

private:
	mutable T *m_tP;
};

template<typename T>
SmartP<typename T>::SmartP(T *p)
{
	printf("SmartP(*)\n");
	m_tP = p;
	p->Add();
}

template<typename T>
SmartP<typename T>::SmartP(SmartP &p)
{
	printf("SmartP(SmartP)\n");
	m_tP = p.Get();
	m_tP->Add();
}

template<typename T>
SmartP<typename T>::~SmartP()
{
	if (m_tP)
	{
		int count = m_tP->Release();
		if (count <= 0)
		{
			delete m_tP;
		}
	}
}

template<typename T>
SmartP<typename T> &SmartP<typename T>::operator =(SmartP &p)
{
	printf("operator=\n");
	if (this == &p)
	{
		return *this;
	}

	if (m_tP)
	{
		int count = m_tP->Release();
		if (count <= 0)
		{
			delete m_tP;
		}
	}

	m_tP = p.Get();
	m_tP->Add();
	return *this;
}

template<typename T>
T *SmartP<typename T>::operator ->()
{
	return m_tP;
}

测试程序：

class Test : public Reference
{
public:
	Test()
	{
		ch = new char[1024*1024*200];
		memset(ch, 0, 1024 * 1024 * 200);
		strcpy_s(ch, 3, "ch");
	}

	~Test()
	{
		delete[]ch;
		printf("=============\n");
	}

	char *ch;
};

int _tmain(int argc, _TCHAR* argv[])
{
	{
		SmartP<Test> p = new Test();
		{
			SmartP<Test> p1 = SmartP<Test>(new Test());
			p1 = p;
			printf("%s\n", p1->ch);
		}

	}
	return 0;
}