#include<iostream>
#include<string>
#include <stdio.h>
#include <stdlib.h>
using namespace std;
template<typename T>
class CDArray
{
private:
	T *m_pData; // 存放数组的动态内存指针
	int m_nSize; // 数组的元素个数
	int m_nMax; //数组的内存空间大小
private:
	void Init(); // 初始化 
	void Free(); // 释放动态内存
	inline int InvalidateIndex(int nIndex); // 判断下标的合法性(数组下标)
public:
	CDArray(); // 缺省构造函数
	CDArray(int nSize, T dValue ); // 其他构造函数，设置一定数组大小，并设置全部元素为0；当然还可以定义其他不同参数的构造函数，以方便用户使用
	CDArray(const CDArray& arr); // 拷贝构造函数（最好为全部包含动态分配成员的类都提供拷贝构造函数）
	~CDArray(); // 析构函数
	void Print(); // 输出显示全部数组元素的值
	int GetSize(); // 获取数组大小（元素个数）
	int SetSize(int nSize); // 重新设置数组的大小。注：若nSize小于原数组大小，可截断取前nSize个元素作为新数组的元素；若nSize大于原数组大小，新增的元素的值设置缺省值0即可
	double GetAt(int nIndex); // 获取某个元素
	double  operator[] (int nIndex) const;  // 重载[]操作符，以便像传统数组那样通过a[k]来获取元素值
	int SetAt(int nIndex, T dValue); // 设置某个元素的值
	int Pushback(T dValue); // 追加一个新的元素到数组末尾
	int DeleteAt(int nIndex); // 从数组中删除一个元素
	int InsertAt(int nIndex, T dValue); // 插入一个新的元素到数组中
	CDArray  &CDArray::operator = (const CDArray& array);   // 重载赋值操作符号"="
};
template<typename T>
void CDArray<T>::Init()// 初始化
{
	m_nMax = 1;
	m_nSize = 0;
	m_pData = new T[m_nMax];
}
template<typename T>
void CDArray<T>::Free()// 释放动态内存
{
	delete []m_pData;
}
template<typename T>
int CDArray<T>::InvalidateIndex(int nIndex)
{
	if(nIndex >= 0 && nIndex <m_nSize)
		return 0; //表示下标合法
	else
		return 1;//下标异常
}
template<typename T>
CDArray<T>::CDArray()
{
	Init();
}
template<typename T>
CDArray<T>::CDArray(int nSize, T dValue )
{
	dValue = 0;
	if(nSize == 0)
	{
		Init();
	}
	else
	{
		m_nSize = nSize;
		m_nMax = nSize * 2;
		for(int i = 0 ; i < nSize ; ++i)
		{
			m_pData[i] = dValue;
		}
	}
}
template<typename T>
CDArray<T>::CDArray( const CDArray & arr)
{
	m_nSize = arr.m_nSize; //复制常规成员
	m_nMax = arr.m_nMax;
	m_pData = new double[m_nMax];
	std::memcpy( m_pData , arr.m_pData , (m_nMax * sizeof(double)));
}
template<typename T>
CDArray<T>::~CDArray()
{
	CDArray<T>::Free();
}
template<typename T>
void CDArray<T>::Print()
{
	if(m_nSize == 0)
	{
		std::cout<<"Error : The array is empty,so it can"t be printed."<<endl;
	}
	else
	{
		for( int i = 0 ; i < m_nSize ; i++ )
		{
			std::cout<<m_pData[i]<<" ";
		}
		std::cout<<endl;
	}
}
template<typename T>
int CDArray<T>::GetSize()
{
	return m_nSize;
}
template<typename T>
int CDArray<T>::SetSize(int nSize) //题中返回值为INT 个人认为返回值为VOID。
{
	if( nSize < m_nSize) //截断
	{
		for(int i = m_nMax ; i < m_nSize ; i ++)
		{
			m_pData[i] = 0;
		}
	}
	if( nSize > m_nSize && nSize <= m_nMax)//设置数组的大小未大于内存空间，仅需在后添0即可
	{
		for(int i = m_nSize ; i < nSize ; i++)
		{
			m_pData[i] = 0;
		}
	}
	if( nSize > m_nMax) //大于内存空间，需要重新分配内存空间
	{
		m_nMax = nSize; //重新分配内存空间大小
		T *temp = new T[m_nMax*sizeof(T)];//临时转存数组
		std::memcpy( temp , m_pData , (m_nSize * sizeof(T)) );//拷贝数组
		for(int  i = m_nSize ; i < nSize ; i++)
		{
			temp[i] = 0;
		}
		delete []m_pData;
		m_pData = temp;
	}
	m_nSize = nSize;
	return 0;
}
template<typename T>
double CDArray<T>::GetAt(int nIndex)
{
	if(InvalidateIndex(nIndex))//判断下标能否合法
	{
		std::cout<<"The index is invalid."<<endl;
		exit(0);
	}
	return m_pData[nIndex];
}
template<typename T>
double CDArray<T>::operator[](int nIndex) const
{
	if(nIndex < 0 || nIndex >= m_nSize)//判断下标能否合法
	{
		std::cout<<"The index is invalid."<<endl;
		exit(0);
	}
	return m_pData[nIndex];
}
template<typename T>
int CDArray<T>::SetAt(int nIndex, T dValue) //重新设置数组内元素的值，无需返回值
{
	if(InvalidateIndex(nIndex))//判断下标能否合法
	{
		std::cout<<"The index is invalid."<<endl;
		exit(0);
	}
	else
	{
		m_pData[nIndex] = dValue;
	}
	return 0;
}
template<typename T>
int CDArray<T>::Pushback(T dValue)    //重新设置数组内元素的值，无需返回值
{
	if(m_nSize < m_nMax)
	{
		m_pData[m_nSize] = dValue;     //m_nSize++;//数组大小加1
	}
	else
	{
		m_nMax = (m_nSize + 1) * 2;    //重新分配内存空间大小
		T *temp = new T[m_nMax];    //临时转存数组
		std::memcpy( temp , m_pData , (m_nSize * sizeof(T)) );//拷贝数组
		delete []m_pData;
		m_pData = temp;
		m_pData[m_nSize] = dValue;    //数组大小加1
	}
	m_nSize++;//数组大小加1
	return 0;
}
template<typename T>
int CDArray<T>::DeleteAt(int nIndex)
{
	if(InvalidateIndex(nIndex))//判断下标能否合法
	{
		std::cout<<"Error:The index is invalid."<<endl;
		exit(0);
	}
	else
	{
		for(int i = nIndex ; i <m_nSize ; i++) //修改后续数组
		{
			m_pData[i] = m_pData[i+1];
		}
		m_pData[m_nSize - 1] = 0 ;
		m_nSize--;
	}
	return 0;
}
template<typename T>
int CDArray<T>::InsertAt(int nIndex, T dValue)
{
	if(nIndex < 0 || nIndex > m_nSize)    //判断下标能否合法(一开始写的程序当中判断式为nIndex >= m_nSize，这样测试代码中的类a中无法插入元素)
	{
		std::cout<<"Error: The index is invalid."<<endl;
		return 0;
	}
	if( m_nSize < m_nMax)    //数组未超过内存空间 直接插入
	{
		for(int i = (m_nSize - 1) ; i >= nIndex ; i--)
		{
			m_pData[ i + 1] = m_pData[i];
		}
		m_pData[nIndex] = dValue;
	}
	else
	{
		m_nMax = m_nSize * 2; //重新分配内存空间大小
		T *temp = new T[m_nMax];//临时转存数组
		std::memcpy( temp , m_pData , (m_nSize * sizeof(double)) );//拷贝数组
		delete []m_pData;
		m_pData = temp;
		for(int i = (m_nSize - 1) ; i >= nIndex ; i--)
		{
			m_pData[ i + 1] = m_pData[ i ];
		}
		m_pData[nIndex] = dValue;
	}
	m_nSize++;//数组大小加1
}
template<typename T>
CDArray<T>  &CDArray<T>::operator = (const CDArray& array)
{
	if (&array != this)
	{
		this->~CDArray();
		new (this) CDArray(array);
	}
	return *this;
}
int main()
{
	CDArray<double> a;
	a.InsertAt(0, 2.1);
	a.Print();
	a.Pushback(3.0);
	a.Pushback(3.1);
	a.Pushback(3.2);
	a.Print();
	a.DeleteAt(0);
	a.Print();
	a.InsertAt(0, 4.1);
	a.Print();
	CDArray<double> acopy = a;  //此处用到了拷贝构造函数
	acopy.Print();
	CDArray<double> acopy2 (a);  //该语句等同于上面的语句，都是初始化
	acopy2.Print();
	CDArray<double> acopy3; 
	acopy3 = a;                    //此处用到了赋值操作符号"="的重载
	acopy3.Print();
	CDArray<int> b;
	b.Pushback(21);
	b.Print();
	b.DeleteAt(0);
	b.Print();
	b.Pushback(22);
	b.SetSize( 5 );
	b.Print();
	CDArray<char> c;
	c.Pushback("a");
	c.Pushback("b");
	c.Pushback("c");
	c.InsertAt(0, "d");
	c.Print();
	//system("pause");
	return 0;
}

有问题欢迎继续追问，满意请及时结贴，谢谢