简化版Vector实现

/*
功能：简化版vector
说明：参照《Data Structures with C++ Using STL》第二版编写,
		没有编写异常处理模块，
		实现构造函数，复制构造函数，析构函数，赋值运算重载，下标运算重载，
		尾部添加元素push_back， 删除元素pop_back，取尾部元素back()
		获取向量大小size（），容量capacity（），判断向量是否为空empty（）
*/
#include <iostream>
using namespace std;
template <typename T>
class minVector{
public:
	minVector(int size = 0);
	//构造函数
	//后置条件：使用元素数目和容量分配数组，所有元素被初始化为T()
	//T()是类型T的默认值
	minVector(const minVector<T>& obj);
	//复制构造函数
	//后置条件：以obj为副本生成当前向量
	~minVector();
	//析构函数
	//后置条件：动态数组被销毁
	minVector& operator =(const minVector<T>& rhs);
	//赋值运算符
	//后置条件：当前向量与rhs有相同的数据
	T& operator [](int i);
	//下标访问运算符重载
	//前提条件：0<= i < vSize, 超出范围产生一个indexRangerError异常
	const T& operator [](int i) const;
	//常量版本，minVector为常量时使用
	void push_back(const T& item);
	//向向量的尾部插入元素
	//后置条件：向量的大小加1
	void pop_back();
	//删除向量尾部的元素
	//前提条件：向量非空，若向量为空，则产生一个underflowError异常
	T& back();
	//返回向量尾部的元素
	//前提条件：向量非空，如果向量为空，则产生一个underflowError异常
	const T& back() const;
	//常量版本，minVector为常量时使用
	int size() const;
	//返回当前向量的大小
	bool empty() const;
	//判断当前向量是否为空，若为空，返回true，否则返回false
	int capacity() const;
	//返回当前容量

private:
	int vCapacity;	//可用空间的大小
	int vSize;		//表中元素个数
	T * vArr;		//动态数组
	void reserve(int n, bool copy);
	//仅当n>vCapacity时被公有函数调用，拓展向量的容量到n个元素，如果copy==true，现有元素被复制到新的空间，
	//删除旧的动态数组，如果分配内存失败，则产生一个memoryAllocationError异常

};

//构造函数，初始化vSzie和vCapacity， 分配动态数组，有vSize个整数
template <typename T>
minVector<T>::minVector(int size) :vSize(0), vCapacity(0), vArr(NULL)
{
	int i;
	//如果size为0，则vSize 和 vCapacity为0，vArr为NULL,只是返回
	if (size == 0)
		return;
	//设置容量为size，建立向量，没有要删除的动态数组，copy=false
	reserve(size, false);
	reserve(size, false);
	//把size 赋值给vSize
	vSize = size;
	//复制T()到每个向量元素
	for (i = 0; i < vSize; i++)
	{
		vArr[i] = T();
	}
}

//复制构造函数
template <typename T>
minVector<T>::minVector(const minVector<T>& obj)
{
	int i;
	reverse(obj.vSize, false);
	vSize = obj.vSize;
	vCapacity = obj.vCapacity;

	for (i = 0; i < vSize; i++)
		vArr[i] = obj.vArr[i];

	return *this;
}
//析构函数
template <typename T>
minVector<T>::~minVector()
{
	if (vArr != NULL)
	{
		delete[] vArr;
	}
}

//赋值运算符
template <typename T>
minVector<T>& minVector<T>::operator =(const minVector<T>& rhs)
{
	int i;
	//检查vCapacity是否需要分配新的数组
	if (vCapacity < rhs.vSize)
	{
		reverse(rhs.vSize, false);
	}
	vSize = rhs.vSize;
	//从rhs.vArr中复制数据项到vArr数组
	for (i = 0; i < vSize; i++)
		vArr[i] = rhs.vArr[i];

	return *this;
}

//重载下标运算符
template <typename T>
T& minVector<T>::operator[](int i)
{
	if (i < 0 || i >= vSize)
	{
		//处理异常
	}
	return vArr[i];
}

//push_back
template <typename T>
void minVector<T>::push_back(const T& item)
{
	//如果空间满了，则分配更多的容量
	if (vSize == vCapacity)
	{
		if (vCapacity == 0)
		{
			//如果容量为0，则设置容量为1，设置copy为false，不存在现有元素
			reserve(1, false);
		}
		else
		{
			//容量加倍
			reserve(2 * vCapacity, true);
		}

	}
	vArr[vSize] = item;
	vSize++;
}
//pop_back
template <typename T>
void minVector<T>::pop_back()
{
	if (vSize == 0)
	{
		//处理异常
	}

	vSize--;

}

//back取尾部的元素
template <typename T>
T& minVector<T>::back()
{
	if (vSize == 0)
	{
		//处理异常
	}
	return vArr[vSize - 1];
}
//返回当前向量的大小
template <typename T>
int minVector<T>::size() const
{
	return vSize;
}
//判断当前向量是否为空，若为空，返回true，否则返回false
template <typename T>
bool minVector<T>::empty() const
{
	if (vSize == 0)
		return true;
	
	return false;
}


//返回当前容量
template <typename T>
int minVector<T>::capacity() const
{
	return vCapacity;
}



//拓展容量
template <typename T>
void minVector<T>::reserve(int n, bool copy)
{
	T * newArr;
	int i;
	//分配新的n个元素的动态数组
	newArr = new T[n];
	if (newArr == NULL)
	{
		//异常处理

	}
	//若copy为true,则从旧表复制到新表
	if (copy)
	{
		for (i = 0; i < vSize; i++)
			newArr[i] = vArr[i];
	}
	//如果vArr为NULL，向量初始为空，则没有要删除的内存，否则，删除初始数组
	if (vArr != NULL)
	{
		delete[] vArr;
	}
	//更新vCapacity和vArr
	vCapacity = n;
	vArr = newArr;
}