简单内存管理

#ifndef __CMem__H_
#define __CMem__H_
#include "CLogmanager.h"

using namespace std;
//堆分配内存自动释放  
template<typename T>
class CMem
{
public:
	CMem() :m_pData(NULL), m_iSize(0){}
	CMem(const unsigned int iSize);
	CMem(const CMem<T>& c);
	CMem<T>& operator =(const CMem<T>& c);
	~CMem();
	void Init(const unsigned int iSize);
	void Reset(const unsigned int iSize);
	T* Data(unsigned int = 0/*偏移量*/);
	inline const unsigned int Size() const{ return m_iSize; }
	inline void SetData(T* const pData){ m_pData = pData; }
	inline void SetSize(const unsigned int iSize){ m_iSize = iSize; }
	
private:
	T* m_pData;
	unsigned int m_iSize;
};

template<typename T>
void CMem<T>::Init(const unsigned int iSize)
{
	ASSERT_RET(iSize > 0);
	m_iSize = iSize;
	m_pData = new T[m_iSize];
	ASSERT_RET(NULL != m_pData);
	//LOG_ERR("new %d", m_iSize);
}

template<typename T>
void  CMem<T>::Reset(const unsigned int iSize)
{
	ASSERT_RET(iSize > 0);
	CMem cTmp(iSize);
	T* pTmp = cTmp.GetData();
	const unsigned int iSize = cTmp.GetSize();

	cTmp.SetData(this->m_pData);
	cTmp.SetSize(this->m_iSize);

	this->m_pData = pTmp;
	this->m_iSize = iSize;
}

template<typename T>
CMem<T>::CMem(const unsigned int iSize) :m_pData(NULL), m_iSize(0)
{
	Init(iSize);
}

template<typename T>
CMem<T>::CMem(const CMem<T>& c)
{
	this->m_iSize = c.m_iSize;
	this->m_pData = NULL;
	if (this->m_iSize > 0)
	{
		this->m_pData = new T[this->m_iSize];
		ASSERT_RET(NULL != this->m_pData);
		memcpy(this->m_pData, c.m_pData, this->m_iSize * sizeof(T));
		//LOG_ERR("new %d", this->m_iSize);
		sTmp->suc += m_iSize;
	}
}

template<typename T>
CMem<T>& CMem<T>::operator =(const CMem<T>& c)
{
	if (this != &c)
	{
		CMem cTmp(c);
		T* pTmp = cTmp.GetData();
		const unsigned int iSize = cTmp.GetSize();
		
		cTmp.SetData(this->m_pData);
		cTmp.SetSize(this->m_iSize);

		this->m_pData = pTmp;
		this->m_iSize = iSize;
	}
}

template<typename T>
CMem<T>::~CMem()
{
	if (m_iSize > 0 && NULL != m_pData)
	{
		//LOG_ERR("delete %d", this->m_iSize);
		delete[] m_pData;
		m_pData = NULL;
		m_iSize = 0;
	}
}

template<typename T>
T* CMem<T>::Data(unsigned int iOffset/*偏移量*/)
{
	ASSERT_RET_VALUE(m_iSize > iOffset, NULL);

	return static_cast<T*>(m_pData + iOffset);
}

#endif