感觉用C++中的构造函数、析构函数等类的特点来描述一些数据结构更加易读，更加合理，便捷。但有一个问题，编译器不支持模板的分离编译，很不舒服

#include <iostream>
using namespace std;

template<class T>
class CArray
{
public:
	CArray(const int &iMax);
	CArray();
	~CArray();
	
	void Create(const int &iMax);
	void Destroy();
	void Print();
	bool IsEmpty();
	bool IsFull();
	void Append(const T &data);
	int GetLength();
	int GetMax();
	bool Delete(const int &pos);
	bool Insert(const int &pos,const T &data);
	void operator+=(const T &data);

private:
	T *m_pArray;
	int m_len;
	int m_max;

	void Reset();
	
};

template<class T>
CArray<T>::CArray(const int &iMax)
{
	Create(iMax);
}

template<class T>
CArray<T>::~CArray()
{
	Destroy();
}

template<class T>
void CArray<T>::Create(const int &iMax)
{
	m_pArray = new T[iMax];
	m_max = iMax;
	m_len = 0;
	memset(m_pArray,sizeof(m_pArray));
}

template<class T>
void CArray<T>::Destroy()
{
	delete [] m_pArray;
}

template<class T>
void CArray<T>::Print()
{
	if(IsEmpty())
	{	
		cout<<"没有数据！"<<endl;
	}
	else
	{
		for(int ix =0 ; ix < m_len ; ++ix)
		{
			cout<<m_pArray[ix]<<",";
		}
		cout<<endl;
	}
}

template<class T>
bool CArray<T>::IsEmpty()
{
	if(0 == m_len)
	{
		return true;
	}
	else
	{
		return false;
	}
}

template<class T>
bool CArray<T>::IsFull()
{
	if(m_len == m_max)
	{
		Reset();
		return false;
	}
	else
	{
		return false;
	}
}

template<class T>
void CArray<T>::Append(const T &data)
{
	if(!IsFull())
	{
		++m_len;
		m_pArray[m_len - 1] = data;
	}
}

template<class T>
int CArray<T>::GetLength()
{
	return m_len;
}

template<class T>
bool CArray<T>::Delete(const int &pos)
{
	if(pos > m_len || pos <= 0)
	{
		cout<<"位置不合法"<<endl;
		return false;
	}
	for(int ix = pos - 1 ; ix < m_len - 1 ; ++ ix)
	{
		m_pArray[ix] = m_pArray[ix + 1];
	}
	--m_len;
	return true;
}

template<class T>
void CArray<T>::operator+=(const T &data)
{
	this->Append(data);
}

template<class T>
bool CArray<T>::Insert(const int &pos,const T &data)
{
	if(IsFull())
	{
		return false;
	}
	else
	{
		for(int ix = m_len - 1 ; ix >= pos - 1 ; -- ix)
		{
			m_pArray[ix + 1] = m_pArray[ix];		
		}
		m_pArray[pos - 1] = data;
		++m_len;

		return true;
	}
	
}

template<class T>
CArray<T>::CArray()
{
	Create(5);
}

template<class T>
void CArray<T>::Reset()
{
	T *pT = new T[m_max * 2];
	memset(pT,sizeof(pT));
	for(int ix = 0 ; ix < m_len ; ++ ix)
	{
		pT[ix] = m_pArray[ix];
	}
	delete [] m_pArray;
	
	m_pArray = pT;
	m_max = m_max * 2;
}

template<class T>
int CArray<T>::GetMax()
{
	return m_max;
}