模拟了一个向量类：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;
}
}
}