text: #ifndef VECTOR_H
  #define VECTOR_H
  
  #include "dsexceptions.h"
  // 加入后就可以识别NULL
  #include <stddef.h>
  
  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; }
  
      bool empty( ) const
        { return size( ) == 0; }
      int size( ) const
        { return theSize; }
      int capacity( ) const
        { return theCapacity; }
  
      Object & operator[]( int index )
      {
                                                       #ifndef NO_CHECK
          if( index < 0 || index >= size( ) )
              throw ArrayIndexOutOfBoundsException( );
                                                       #endif
          return objects[ index ];
      }
  
      const Object & operator[]( int index ) const
      {
                                                       #ifndef NO_CHECK
          if( index < 0 || index >= size( ) )
              throw ArrayIndexOutOfBoundsException( );
                                                       #endif
          return objects[ index ];
      }
  
      const Vector & operator= ( const Vector & rhs )
      {
          if( this != &rhs )
          {
              delete [ ] objects;
              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 );
          theSize = newSize;
      }
  
      void reserve( int newCapacity )
      {
          Object *oldArray = objects;
      
          int numToCopy = newCapacity < theSize ? newCapacity : theSize;
          newCapacity += SPARE_CAPACITY;
      
          objects = new Object[ newCapacity ];
          for( int k = 0; k < numToCopy; k++ )
              objects[ k ] = oldArray[ k ];
      
          theSize = numToCopy;
          theCapacity = newCapacity;
      
          delete [ ] oldArray;
      }
  
        // Stacky stuff
      void push_back( const Object & x )
      {
          if( theSize == theCapacity )
              reserve( 2 * theCapacity + 1 );
          objects[ theSize++ ] = x;
      }
  
      void pop_back( )
      {
          if( empty( ) )
              throw UnderflowException( );
          theSize--;
      }
  
      const Object & back ( ) const
      {
          if( empty( ) )
              throw UnderflowException( );
          return objects[ theSize - 1 ];
      }
  
        // Iterator stuff: not bounds checked
      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;
  };
  
  #endif
  