向量vector的实现

template <typename Object>
class vector
{
	public:
		explicit vector ( int initSiez = 0 )
		:thiSize( initSize ), theCapacity( initSize + SPARE_CAPACITY)
		{ object = new object [ theCapacity ];}
		vecotr( const vector & rhs) : object( NULL)
		{ operator=( rhs );}
		~vector()
		{ delete [] objects; }
	
	const vector & operator= ( const vector & rhs)
	{
		if( this != &rhs)
		{
			delete [] object;
			theSize = rhs.size();
			theCapacity = rhs.theCapacity;
			
			objects = new Object( capacity() );
			for( int k = 0; k < size(); k++)
				objects[ k ] = rhs.objects[ k ];
		}
		return *this;
	}
	
	void resize(int newSize)
	{
		if( newSize > theCapacity )
			reserve( newSize * 2 + 1)
		theSize = newSize;
	}
	
	void reserve( int newCapacity )
	{
		if( newCapacity < theSize )
			return;
			
		Object *oldArray = objects;
		objects = new Object[ newCapacity ];
		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_iteraotr 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;
}