模拟了一个向量类：miniVector（参考《数据结构C++语言描述》第五章）

#include <iostream>
using namespace std;

template <typename T>
class miniVector
{
public:
 miniVector( int size = 0 );
 miniVector( const miniVector<T>& obj );
 ~miniVector();
 miniVector& operator=( const miniVector<T>& rhs );
 T& operator[]( int i );
 const T& operator[]( int i ) const;
 void push_back(const T& item);
 void pop_back();
 T& back() const;
 int size() const;
 int capacity() const;
 bool empty() const;
 void insert( int i, const T& item );
 void erase( int i );
private:
 int vSize;
 int vCapacity;
 T *vArr;
 void reserve( int size, bool copy );
};

template <typename T>
void miniVector<T>::reserve( int size, bool copy )
{ 
 T *newArr;
 newArr = new T[size];
 if( newArr == NULL )
 {
  cerr << "There is no available memory to allocate!" << endl;
  exit( -1 );
 }
 if( copy )
 {
  for(int i = 0; i < vSize; i++ )
  {
   newArr[i] = vArr[i];
  }
 }

 if( vArr != NULL )
  delete []vArr;
 vArr = newArr;
 vCapacity = size;
}

template <typename T>
miniVector<T>::miniVector(int size) :
 vSize(0), vCapacity(0), vArr(NULL)
{
 if( size < 0 )
 {
  cerr << "constructor function, the first parameter cannot be assigned to the minus number!" << endl;
  exit( -1 );
 }
 if( size != 0 )
 {
  reserve( size, false );
  vSize = size;
  for( int i = 0; i < vSize; i++ )
   vArr[i] = T();
 }
}

template <typename T>
miniVector<T>::~miniVector()
{
 if( vArr != NULL )
  delete []vArr;
}

template <typename T>
miniVector<T>::miniVector( const miniVector<T>& obj )
{
 if( obj.vCapacity == 0 )
  return ;
 
 reserve( obj.vCapacity, false );
 
 for( int i = 0; i < obj.vSize; i++ )
 {
  vArr[i] = obj.vArr[i];
 }
 vSize = obj.vSize;
}

template <typename T>
miniVector<T>& miniVector<T>::operator=( const miniVector<T>& rhs )
{
 if( this == &ths )
  return *this;
 if( vArr != NULL )
 {
  delete []vArr;
  reserve( rhs.vCapacity, false );
  
  for( int i = 0; i < rhs.vSize; i++ )
  {
   vArr[i] = rhs.vArr[i];
  }
  vSize = rhs.vSize;
 }
 else
 {
  vSize = 0;
  vCapacity = 0;
 }
}

template <typename T>
T& miniVector<T>::operator[]( int i )
{
 if( i < 0 || i > vSize -1 )
 {
  cerr << i <<" is not in the scale of miniVector! " << endl;
  exit( -1 );
 }
 return vArr[i];
}

template <typename T>
const T& miniVector<T>::operator[]( int i ) const
{
 if( i < 0 || i > vSize -1 )
 {
  cerr << i <<" is not in the scale of miniVector! " << endl;
  exit( -1 );  
 }
 return vArr[i];
}

template <typename T>
void miniVector<T>::push_back( const T& item )
{
 if( vSize == vCapacity )
 {
  if( vCapacity == 0 )
   reserve( 1, false );
  else
   reserve( 2 * vCapacity, true );
 }
 vArr[vSize] = item;
 vSize++;
}

template <typename T>
void miniVector<T>::pop_back()
{
 if( empty() )
 {
  cerr << " miniVector is empty, you cannot get the value!" << endl;
  exit( -1 );
 }
 vSize--;
}

template <typename T>
T& miniVector<T>::back() const
{
 if( empty() )
 {
  cerr << " miniVector is empty, you cannot get the value!" << endl;
  exit( -1 );
 }
 return vArr[vSize-1];
}

template <typename T>
int miniVector<T>::size() const
{
 return vSize;
}

template <typename T>
int miniVector<T>::capacity() const
{
 return vCapacity;
}

template <typename T>
bool miniVector<T>::empty() const
{
 if( vSize == 0 )
  return true;
 else
  return false;
}

template <typename T>
void miniVector<T>::insert( int i, const T& item )
{
 if( i == vSize  )
  push_back( item );
 else if( i > vSize )
 {
  cerr << i <<" is not in the scale of miniVector!" << endl;
  exit(-1);
 }
 else
 {
  if( vSize == vCapacity )
  {
   if( vCapacity == 0 )
    reserve( 1, false );
   else
    reserve( 2 * vCapacity, true );
  }
  int j;
  for( j = vSize; j >= 0; j-- )
  {
   if( j == i )
    break;
   vArr[j] = vArr[j-1];
  }
  vArr[j] = item;
  ++vSize;
 }
}

template <typename T>
void miniVector<T>::erase( int i )
{
 if( i < 0 || i > vSize - 1 )
 {
  cerr << i << " is not in the scale of miniVector!" << endl;
  exit(-1);
 }
 if( i == vSize - 1 )
 {
  pop_back();
 }
 else
 {
  int j;
  for( j = i + 1; j < vSize; j++ )
  {
   vArr[j - 1] = vArr[ j ];
  }
  --vSize;
 }
}

template <typename T>
void insertOrder( miniVector<T>& v, const T& item )
{
 int i;
 for( i = 0; i < v.size(); i++ )
 {
  if( item < v[i] )
   break;
 }
 v.insert( i, item );
}

template <typename T>
void removeDuplicates( miniVector<T>& v )
{
 for( int i = 1; i < v.size(); i++ )
 {
  if( v[i] == v[i-1] )
  {
   v.erase( i );
   --i;
  }
 }
}