Vector easy to achieve

template <typename Object>
class Vector {
public:
	explicit Vector(int initSize = 0) : theSize(initSize), theCapacity(initSize + SPARE_CAPACITY) {
		objects = new Object[theCapacity];
	}
	Vector(const Vector& rhs) : objects(NULL) {
		operator=(rhs);
	}
	~Vector() { delete[] objects; }

	void operator= (const Vector& rhs) {
		if (this != &rhs) {
			delete[] objects;
			theSize = rhs.theSize;
			theCapacity = rhs.theCapacity;
			objects = new Object[capacity()];
			for (int i = 0; i < size(); i++)
				objects[i] = rhs[i];
		}
	}

	void reserve(int newCapacity) {
		if (newCapacity > theCapacity) {
			Object* oldArray = objects;
			objects = new Object[newCapacity];
			for (int i = 0; i < size(); i++)
				objects[i] = oldArray[i];
			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& object) {
		if (capacity() == size()) {
			reserve(2 * theCapacity + 1);
			
		}
		objects[theSize++] = object;
	}

	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 {SPARE_CAPACITY=16};

private:
	int theSize;
	int theCapacity;
	Object* objects;
};

　　Codes from "Algorithm and Data Structure Analysis: C ++ Description"