用类模板实现的【动态数组模板】

动态数组模板的特点：

1. 自动扩容。构造函数里初始化的长度为10，数组被填满时会自动扩容，保留数据不变的前提下重新分配地址长度。
2. 任何数据类型的数组都可以创建，前提是注意打印输出的格式，尤其是自定义的class类型，需要重载"<<"符号。参考例程中的Point。
3. 实现功能：增，删，查，打印。
   add(int dat)：向数组插入一个数据
   get(int index)：按照索引（下标）获取数组中的数据
   size()：得到数组的大小
   travel()：把数组打印一遍
   remove(int index)：按照索引（下标）删除数组中的数据

//动态数组-类模板
#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>

using namespace std;

//自定义一个类：点。类内重载了"<<"符号，方便打印输出。
class Point {
public:
	Point() {
	}
	Point(int x, int y) :
			x(x), y(y) {
	}
	Point(Point& p) {
		this->x = p.x;
		this->y = p.y;
	}
	void show() {
		printf("Point[x=%d, y=%d]", x, y);
	}
	friend ostream& operator<<(ostream& os, const Point& p);
private:
	int x, y;
};
ostream& operator<<(ostream& os, const Point& p) {  //重载“<<”号
	os << "Point[x=" << p.x << ", y=" << p.y << "]";
	return os;
}

//动态数组模板基（父）类，可以不写
template<typename T>
class List {
public:
	virtual void add(T dat) = 0; //向数组插入一个数据
	virtual T get(int index) = 0; //按照索引（下标）获取数组中的数据
	virtual int size() = 0; //得到数组的大小
	virtual void travel() = 0; //把数组打印一遍
	virtual int remove(int index) = 0; //按照索引（下标）删除数组中的数据

	virtual ~List() {
	}
};

//动态数组模板的派生（子）类，继承基类
template<typename T>
class ArrayList: public List<T> {
public:
	ArrayList() {
		len = 10;
		arr_Size = 0;
		this->arr = new T[len];
	}
	~ArrayList() {
		delete[] arr;
	}
	void add(T dat) {
		*(arr + arr_Size) = dat;
		arr_Size++;
		if (arr_Size >= len) {
			arr_Expansion();
		}
	}
	int size() {
		return arr_Size;
	}
	void travel() {
		int i = 0;
		printf(
				"============================================================================\n");
		printf("arr_Size:%d\n", arr_Size);
		for (; i < arr_Size; i++) {
			cout << *(arr + i) << "\t";
			if (i % 10 == 9) {
				printf("\n");
			}
		}
		printf("\n");
		printf(
				"============================================================================\n");
	}

	T get(int index) {  //要加一个index在0~arr_Size之间的判断，不在就是越界，return -1
		if (index < 0 || index > arr_Size) {
			printf("越界\n");
			//return -1;
		}
		return *(arr + index);
	}
	int remove(int index) { //要加一个index在0~arr_Size之间的判断，不在就是越界，return -1
		if (index < 0 || index > arr_Size) {
			printf("越界\n");
			return -1;
		}
		for (int i = index; i < arr_Size; i++) {
			if (index == arr_Size) {
				//*(arr + arr_Size) = '\0';
			}
			*(arr + i) = *(arr + i + 1);
		}
		arr_Size--;
		printf("It is successful to remove!\n");
		return 1;
	}
private:
	int len;
	int arr_Size;
	T* arr;

	void arr_Expansion() {
		T* arr1 = arr;
		len += 10;
		arr = new T[len];
		for (int i = 0; i < len; i++) {
			*(arr + i) = *(arr1 + i);
		}
		delete[] arr1;
	}
};

int main() {
	ArrayList<int> list1; //int型数组
	for (int i = 1; i <= 100; i++) {
		list1.add(i);
	}
	list1.travel();

	ArrayList<double> list2; //double型数组
	for (int i = 1; i <= 100; i++) {
		list2.add(0.01 * i);
	}
	list2.travel();

	ArrayList<char> list3; //char型数组
	for (int i = 32; i <= 100; i++) {
		list3.add(i);
	}
	list3.travel();

	Point p;
	ArrayList<Point> list4;  //自定义类Point型数组
	for (int i = 1; i <= 100; i++) {
		p = Point(i, i);
		list4.add(p);  //list4.add(Point(i, i))的方式不行，用p过渡一下
	}
	list4.travel();
}
	cout << list4.get(50) << endl;

运行结果（Eclipse）：
list1、list2
list3、lit4