ArrayList泛型数组类

/*************************************************************************
 Copyright   : Free
 Author      : Cheng Haifeng
 Date        : 2017-10-17
 Description : ArrayList
 Environment : RAD Studio XE7
 ************************************************************************ */

/*************************************************************************
 T 的需求
 T 如果为内置类型，无特殊需求。
 T 如果为类或结构体，请重载operator ==和>。
 必要时需重载 operator=，无参构造函数和赋值构造函数。
 ************************************************************************ */

// 头文件，用于异常处理。
#include 

template
class ArrayList {
public:
	// 构造函数
	ArrayList() {
		mArray = NULL;
		mCount = 0;
		mCapacity = 0;
	}

	// 析构函数
	~ArrayList() {
		Clear();
		delete[]mArray;
	}

	// 添加元素
	void Add(T t) {
		if (mCount == mCapacity) {
			Grow();
		}
		mArray[mCount] = t;
		mCount++;
	}

	// 插入元素
	void Insert(int idx, T t) {
		CheckIndex(idx);
		if (mCount == mCapacity) {
			Grow();
		}
		for (int i = mCount; i > idx; i--) {
			mArray[i] = mArray[i - 1];
		}
		mArray[idx] = t;
		mCount++;
	}

	// 删除元素，按索引号
	void Delete(int idx) {
		CheckIndex(idx);
		for (int i = idx; i < mCount - 1; i++) {
			mArray[i] = mArray[i + 1];
		}
		mCount--;
	}

	// 返回t在列表中的索引号
	int IndexOf(T t) {
		for (int i = 0; i < mCount; i++) {
			if (mArray[i] == t) {
				return i;
			}
		}
		return -1;
	}

	// 排序 - 升序
	void Sort(bool asc = true) {
		for (int i = 0; i < mCount - 1; i++) {
			for (int j = i + 1; j < mCount; j++) {
				if ((mArray[i] > mArray[j]) == asc) {
					Swap(i, j);
				}
			}
		}
	}

	// 唯一
	void Unique() {
		for (int i = 0; i < mCount - 1; i++) {
			for (int j = i + 1; j < mCount; j++) {
				if (mArray[i] == mArray[j]) {
					Delete(j);
					j--;
				}
			}
		}
	}

	// 删除值为val的元素
	void Remove(T val) {
		for (int i = 0; i < mCount; i++) {
			if (mArray[i] == val) {
				Delete(i);
				i--;
			}
		}
	}

	// 反转数组
	void Reverse() {
		for (int i = 0, j = mCount - 1; i < mCount / 2; i++, j--) {
			Swap(i, j);
		}
	}

	// 交换两个元素
	void Swap(int idx1, int idx2) {
		CheckIndex(idx1);
		CheckIndex(idx2);
		if (idx1 != idx2) {
			T t = mArray[idx1];
			mArray[idx1] = mArray[idx2];
			mArray[idx2] = t;
		}
	}

	// 清空数据
	void Clear() {
		mCount = 0;
	}

	// 设置数组容量
	void SetCapacity(int size) {
		if (size < mCount) {
			Throw("容量太小");
		}
		T* tmp = new T[size];
		if (mArray != NULL) {
			for (int i = 0; i < mCount; i++) {
				tmp[i] = mArray[i];
			}
			delete[]mArray;
		}
		mArray = tmp;
		mCapacity = size;
	}

	// 获得数组容量
	int Capacity() {
		return mCapacity;
	}

	// 获得元素个数
	int Count() {
		return mCount;
	}

	// 设置数据个数
	void SetCount(int size) {
		if (size < 0) {
			Throw("数据个数不能为负数");
		}
		if (size > mCapacity) {
			SetCapacity(size);
		}
		mCount = size;
	}

	// 获得元素的引用
	T& Items(int idx) {
		CheckIndex(idx);
		return mArray[idx];
	}

	// 重载操作符[]
	T& operator[](int idx) {
		return Items(idx);
	}

protected:

	// 元素数量
	int mCount;

	// 数组容量
	int mCapacity;

	// 数组指针
	T* mArray;

	// 抛出异常信息
	void Throw(String msg) {
		throw Exception(msg);
	}

	// 增加数组容量
	void Grow() {
		int delta;
		if (mCapacity > 64) {
			delta = mCapacity / 4;
		}
		else if (mCapacity > 16) {
			delta = 16;
		}
		else {
			delta = 4;
		}
		SetCapacity(mCapacity + delta);
	}

	// 检查索引
	void CheckIndex(int idx) {
		if (idx < 0 || idx >= mCount) {
			Throw("索引超限");
		}
	}
};