向量类模板的实现

template <typename T>
class Vector
{
private:
	T* data;
	int size;
	int max;
public:
	enum { SPARE_MAX = 16 }; 
	explicit Vector(int n = 0) :size(0), max(n + SPARE_MAX)
	{
		data = new T[max];
	}

	Vector(const Vector& v)
	{
		data=v.data;
        size=v.size;
        max=v.size;
	}

	~Vector() { delete[] data; }

	Vector& operator=(const Vector& v);

	T& operator[](int id) { return data[id]; }
	const T& operator[](int id) const { return data[id]; }

	bool Empty() const { return size == 0; }//取空
	int Size() const { return size; }//求数据个数
	int Max() const { return max; }//求数据容量
	void Clear() { size = 0; }//清空所有元素

	typedef T* iterator;     //迭代器
	typedef const T* const_iterator;    //常量型迭代器
	iterator Begin() { return data; }
	const_iterator Begin() const { return data; }
	iterator End() { return data + size; }
	const_iterator End() const { return data + size; }

	T& Front() { return data[0]; }//返回首元素的引用
	const T& Front() const { return data[0]; }
	T& Back() { return data[size - 1]; }//返回尾元素的引用
	const T& Back() const { return data[size - 1]; }

	void Push_back(const T& item);//尾插
	void Pop_back()//尾删
	{
		if (!Empty()) size--;
	}

	void Reserve(int newMax);  //扩大数组容量为newMax，并保留原来的数据
	void Resize(int newSize, const T& item);   //把数据个数增加为newSize,保留原来的数据，其余的值为item

	iterator Insert(iterator itr, const T& item); //在itr所指向的位置插入item
	iterator Erase(iterator itr); //删除itr所指向的元素
};

//赋值运算符重载
template<typename T>
Vector<T>& Vector<T>::operator=(const Vector& v)
{
	delete[]data;
	data = new T[v.max];
	size = v.size;
	max = v.max;
	for (int i = 0; i < size; i++)
		data[i] = v.data[i];
	return *this;
}

//尾部插入数据
template<typename T>
void Vector<T>::Push_back(const T& item)
{
	data[size++] = item;
}

//扩大数组容量为newMax，并保留原来的数据
template<typename T>
void Vector<T>::Reserve(int newMax)
{
	if (newMax <= max)
	{
		return;
	}
	T* old = data;
	data = new T[newMax];
	for (int i = 0; i < size; i++)
	{
		data[i] = old[i];
	}
	max = newMax;
	delete[]old;
}

//把数据个数增加为newSize,保留原来的数据，其余的值为item
template<typename T>
void Vector<T>::Resize(int newSize, const T& item )
{
	if (newSize > max)
		Reserve(2 * newSize + 1);
	for (int i = size; i < newSize; i++)
		data[i] = item;
	size = newSize;
}

//基于指针插入数据
template<typename T>
typename Vector<T>::iterator Vector<T>::Insert(iterator itr, const T& item )
{
	if (size == max)
	{
		Reserve(size * 2 + 1);
	}
	for (iterator p = data + size, q = data + size - 1; p != itr; --p, --q)
	{
		*p = *q;
	}
	*itr = item;
	size++;
	return itr;
}

//基于指针删除数据
template<class T>
typename Vector<T>::iterator Vector<T>::Erase(iterator itr)
{
	//从删除位置开始的后一个元素依次前移一位，直到数组最后一个元素移动后，结束
	for (iterator p = itr, q = itr + 1; q != data + size; ++p, ++q)
	{
		*p = *q;
	}
	size--;
	return itr;
}