模擬了一個向量類：miniVector（參考《數據結構C++語言描述》第五章）

原創

2020-02-20 16:32

#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;
  }
}
}