动态数组类模板

实现一个简单的动态数组类模板Array，它由任意多个位置连续的、类型相同的元素组成，其元素个数可在程序运行时改变。它虽然比vector简单，但与vector的工作原理类似。

#include <iostream>
#include <cassert>

using namespace std;

template <class T>
class Array {
private:
	T* list;                                      //T类型指针， 用于存放动态分配的数组内存首地址
	int size;                                    //数组大小（元素个数）
public:
	Array(int sz = 50);                          //含有默认参数的构造函数
	Array(const Array<T>& a);                   //复制构造函数
	~Array();                                   //析构函数
	Array<T>& operator=(const Array<T>& rhs);  //重载“=”使数组对象可以整体赋值
	T& operator[](int i);                       //重载“[]”，使得Array对象可以起到普通数组的作用
	const T& operator[](int i)const;            //“[]”运算符的const版本
	operator T* ();                            //重载T*类型的转换，使得Array对象可以起到普通数组的作用
	operator const T* ()const;                 //T*类型的转换操作符的const版本
	int getSize()const;                        //取数组的大小
	void resize(int sz);                       //修改数组的大小

};

template<class T>
Array<T>::Array(int sz)
{
	assert(sz >= 0);        //sz为数组大小，应当非负，如果是个负数，调试后警告
	size = sz;              //将元素个数赋值给变量size
	list = new T[size];     //动态分配size个T类型的元素空间
}

template<class T>
Array<T>::Array(const Array<T>& a)
{
	size = a.size;                      //取对象a的数组大小并赋值给当前对象的成员
	list = new T[size];                 //动态分配n个T类型的元素空间
	for (int i = 0; i < size; i++)      //从对象a的数组元素复制到当前对象的数组
	{
		list[i] = a.list[i];
	}
}

template<class T>
Array<T>::~Array()
{
	delegate[]list;                    //销毁动态分配的空间
}

template<class T>
Array<T>& Array<T>::operator=(const Array<T>& rhs)
{
	if (&rhs != this)                    //判断rhs对象和当前对象的地址是否一样
	{
		if (size != rhs.size)             //如果当前对象数组大小与rhs对象不一样，则删除数组原有内存，重新分配
		{
			delete[] list;                 //删除数组原有内存
			size = rhs.size;               //设置本对象的数组大小
			list = new T[size];            //重新动态分配n个元素内存
		}
	}
	for (int i = 0; i < size; i++)         //从对象rhs的数组元素复制到当前对象的数组
	{
		list[i] = rhs.list[i];
	}
	return *this;                         //返回当前对象的引用
}

template<class T>
T& Array<T>::operator[](int i)
{
	assert(n >= 0 && n < size);           //检查下标是否越界
	return list[i];                       //返回下标为n的数组元素
}

template<class T>
const T& Array<T>::operator[](int i) const
{
	assert(n >= 0 && n < size);            //检查下标是否越界
	return list[n];                          //返回下标为n的数组元素
}

template<class T>
Array<T>::operator T* ()
{
	return list;                           //返回当前对象中数组的首地址
}

template<class T>
Array<T>::operator const T* () const
{
	return list;                           //返回当前对象中数组的首地址
}

template<class T>
int Array<T>::getSize() const
{
	return size;                            //返回当前对象的数组大小
}

template<class T>
void Array<T>::resize(int sz)
{
	assert(sz >= 0);                      //检查sz是否非负，如果是负数，调试后警告
	if (sz == size)                       //如果指定大小与原有的大小一样，则直接返回
		return;
	T* newList = newT[sz];                 //申请新的大小为sz的内存，
	int n = (sz < size) ? sz: size;        //将sz与size中较小的一个赋值给n
	for (int i = 0; i < n; i++)            //将原有数组的前n个复制到新数组里面  
		newList[i] = list[i];
	delete[]list;                          //删除原来数组
	list = newList;                        //使list指向新数组
	size = sz;                             //更新数组大小
}

类Array大小可变，具有边界检查功能，可以捕捉非法的数组下标。对下标运算符[]和指针转换运算符T*进行了重载，使得Array类的对象可以像普通数组一样使用。

其中的asser的函数的功能，参考C++帮助文档 (assert.h) - C++ Referencehttps://cplusplus.com/reference/cassert/