自己写的CArray类

myArray.h:

#pragma once


template<typename TYPE, typename TYPE_ARG = const TYPE&>
class myArray
{

public:

	myArray(void);
	~myArray(void);

private:
	int m_nSize;//数据长度（也就是实际占用数组的内容的长度）
	int m_nCount;//资源数量(也就是数组的长度)
	TYPE* m_pData;
public:
	
	int GetSize() const//得到数据长度
	{
		return m_nSize;
	}
	int GetCount()const//得到资源的数量
	{
		return m_nCount;
	}
	int GetUpperBound( ) const//得到数组实际使用单元下标上界
	{
		return m_nCount -1;
	}


	TYPE& GetAt(int nIndex) 
	{
		if (nIndex >= 0 && nIndex < m_nSize)
		{
			return m_pData[nIndex];
		}
	}
	//只读对象专用，例如:const CArray<xx,xx> &ar;
	TYPE& GetAt(int nIndex) const
	{
		if (nIndex >=0 && nIndex <m_nSize)
		{
			return m_pData+nIndex;
		}
	}


	TYPE& ElementAt(int nIndex)
	{
		if (nIndex >= 0 && nIndex < m_nSize)
		{
			return m_pData[nIndex];
		}
	}
	//只读对象专用，例如:const CArray<xx,xx> &ar;
	TYPE& ElementAt(int nIndex) const
	{
		if (nIndex >= 0 && nIndex < m_nSize)
		{
			return m_pData[nIndex];
		}
	}


	//只读对象专用，例如:const CArray<xx,xx> &ar;
	TYPE& operator []( int nIndex ) const
	{
		return m_pData[nIndex];
	}
	TYPE& operator []( int nIndex )
	{
		return m_pData[nIndex];
	}
	/************************************************************************/
	/* 以前的版本 const版本返回值是一个对象，现在的版本const版本返回值也是一个对象的引用 */
	/************************************************************************/

	void SetAt(int nIndex, TYPE_ARG newElement)
	{
		if (newElement >=0 && newElement < m_nSize)
		{
			m_pData[nIndex] = newElement;
		}
	}

	void RemoveAll( )
	{
		m_nSize = 0;
	}


	TYPE* GetData()
	{
		return m_pData;
	}
	const TYPE* GetData() const
	{
		return m_pData;
	}

public:
	int Add(TYPE_ARG data );
	void SetSize( int nNewSize);
	void ReMalloc(int nCount);
	void RemoveAt(int nIndex, int nCount = 1);
	void InsertAt(int nIndex, TYPE_ARG data,int nCount);

};

myArray.cpp:

#include "stdafx.h"
#include "myArray.h"
#include <string.h>


template<typename TYPE, typename TYPE_ARG>
myArray<TYPE,TYPE_ARG>::myArray()
{
	m_pData=new TYPE[m_nCount=8];
	m_nSize=0;
}

template<typename TYPE, typename TYPE_ARG>
myArray<TYPE,TYPE_ARG>::~myArray(void)
{
	delete []m_pData;
}

template<typename TYPE, typename TYPE_ARG>
void myArray<TYPE,TYPE_ARG>::ReMalloc(int nCount)
{
	m_nCount = nCount*2;
	TYPE* p = new TYPE[m_nCount];
	memcpy(p,m_pData,sizeof(TYPE)*m_nSize);
	delete []m_pData;
	m_pData = p;
}
template<typename TYPE, typename TYPE_ARG>
void myArray<TYPE,TYPE_ARG>::SetSize( int nNewSize)
{
	if (nNewSize < 0)
		nNewSize = 0;

	m_nSize = nNewSize;

	if (m_nSize > m_nCount)
	{
		ReMalloc(m_nSize);
	}

}

template<typename TYPE, typename TYPE_ARG>
int myArray<TYPE,TYPE_ARG>::Add( TYPE_ARG data )
{
	if (m_nSize >= m_nCount)
		ReMalloc(m_nSize);

	m_pData[m_nSize] = data;
	m_nSize++;
	return m_nSize;
}

template<typename TYPE, typename TYPE_ARG>
void myArray<TYPE,TYPE_ARG>::RemoveAt(int nIndex, int nCount)
{

	if (nIndex > m_nSize)//索引号大于数组实际长度
	{
		return;
	}
	else if (nIndex + nCount >= m_nSize)//索引号加要移除的数量 大于 数组实际的长度
	{
		m_nSize = nIndex;
		return;
	}
	else //索引号加上要移除的数量 小于 数组实际长度
	{
		memcpy(m_pData+nIndex,m_pData+nIndex+nCount,sizeof(TYPE)*(m_nSize-nIndex-nCount));
		m_nSize -= nCount;
	}
}
template<typename TYPE, typename TYPE_ARG>
void myArray<TYPE,TYPE_ARG>::InsertAt(int nIndex, TYPE_ARG data,int nCount)
{
	if (nCount < 0)//插入的数量小于0，直接返回
	{
		return;
	}
	if (nIndex < 0)//要插入的位置索引小于0，则让索引为0
	{
		nIndex = 0;
	}
	if (nIndex >= m_nSize)//索引号大于数组实际长度
	{
		m_nSize = nIndex+ nCount;
		if (m_nSize > m_nCount)//比如数组实际长度为8，在索引12的位置插入5个数字，17 > 16
		{
			ReMalloc(m_nSize);//扩展内存  17*2 = 34，m_nCount = 34
		}
	}
	else//在实际数组中间插入几个数字
	{
		m_nSize = m_nSize + nCount;
		if (m_nSize>m_nCount)
		{
			ReMalloc(m_nSize);
		}
		memcpy(m_pData+nIndex+nCount,m_pData+nIndex,sizeof(TYPE)*(m_nSize-nIndex));
	}
	int i = 0;
	while (i < nCount)
	{
		m_pData[nIndex+i] = data;
		i++;
	}

}

因为是模板，所以使用的时候，要导入myArray.h和myArray.cpp两个文件，或者所有函数都在.h文件当中实现。