实现vector的代码

//vector的定义，实现一个vector，会用也要会写.......
template <typename Object>             //这里的Object就是，int string之类的类型
class Vector
{
public:
	explicit Vector(int initSize=0)       //explicit用来标识这个函数只能显示调用，不能隐式调用，防止出错。这个意思是，如果调用的时候给了initSize就用给的，没给就是0
		:theSize(initSize), theCapacity(initSize+SPARE_CAPACITY)        //构造函数的初始化列表，以一个冒号开始，之后是以逗号分隔的数据成员列表   这里把容量（capacity）初始化的比大小（size）稍微大一点，留了一个余量
	{
		objects = new Object[theCapacity]; //根据容量分配空间
	}

	Vector(const Vector & rhs) :objects(NULL)         //这个是拷贝构造函数，这里先让objects指向NULL，应该是防止浅拷贝，就是让这个和rhs的objects指向不同的空间值相等，而不是指向相同的空间的值相等
	{
		operator=(rhs);                              //调用operator=这个函数
	}

	~Vector()
	{
		delete[] objects;                            //析构函数，释放objects的空间
	}

	const Vector & operator= (const Vector & rhs)  //一般的运算符重载都这样，就是const Vector &s什么之后return *this。实现深拷贝。如果想返回this对象的一个成员，必须用常量引用返回，这里就是const Vector &。函数不能返回局部对象的引用，关于函数能返回怎样的引用也比较复杂，看收藏的博客...不要返回局部对象的引用，这个说的比较多，还有！不能返回函数内部定义的对象，一般都是返回this指的对象，比如这个
	{
		if (this != rhs)         //混淆检测，之后就把原来的objects释放掉，然后重新赋值theSize，theCapacity，object..之后返回this指针
		{
			delete[] objects;
			theSize = rhs.size();
			theCapacity = rhs.theCapacity;
			object = new Object[capacity()];
			for (int k = 0; k < size(); k++)
				object[k] = rhs.objects[k];
		}
		return *this;     //返回对象本身。return this就是返回对象的地址。
	}

	void resize(int newSize)   //改变这个vector本身的大小
	{
		if (newSize > theCapacity)
			reserve(newSize * 2 + 1);  //这里只考虑超过theCapacity的情况，办法就是扩大存储区（把篮子大小变成原来的2倍）
		theSize = newSize;
	}

	void reserve(int newCapacity) //改变这个vector预先给它分配的内存大小。上一个是篮子里有几个苹果，这个是把篮子加大了
	{
		if (newCapacity < theSize)   //扩成比theSize还小的，在逗我，return不管它
			return;

		Object *oldArray = objects;  //oldArray指向老空间
		objects = new Object[newCapacity]; //然后给objects分配新空间
		for (int k = 0; k < theSize; k++)
			objects[k] = oldArray[k];
		theCapacity = newCapacity;
		delete[] oldArray;           //再把老空间释放掉
	}

//以上为主要模块，以下为一些其他的功能
	Object & operator[] (int index)     //返回引用，这样子的话这个元素是可以改的
	{
		return objects[index];
	}
	const Object & operator[](int index) const  //这种是不可以改的,只能观测
	{
		return objects[index];
	}

	bool empty() const
	{
		return size() == 0;
	}

	int size() const
	{
		return theSize;
	}

	int capacity() const
	{
		return theCapacity;
	}

	void push_back(const Object &x)
	{
		if (theSize == theCapacity)
		{
			reserve(2 * theCapacity + 1);
		}
		objects[theSize++] = x;
	}

	void pop_back()
	{
		theSize--;
	}

	const Object & back() const
	{
		return objects[theSize - 1];
	}

//迭代器的定义
	typedef Object * iterator;
	typedef const Object * const_iterator;     //两种迭代器，一个指向的值可以改，一个不可以改

	iterator begin()
	{
		return &objects[0];
	}

	const_iterator begin() const
	{
		return &objects[0];
	}

	iterator end()
	{
		return &objects[size()];
	}

	const_iterator end() const
	{
		return &objects[size()];
	}

	enum{SPACE_CAPACITY=16};          //枚举类型，如果字符串很长，并且没几个，可以用这种办法



private:                           //public的一通操作都是关于这几个的
	int theSize;                   //vector的大小，就是现在存了几个容量
	int theCapacity;               //vector的容量，就是这个vector能存几个元素
	Object* objects;               //vector的每个元素。
};