C++实现动态顺序表

#include <iostream>
using namespace std;
#include <assert.h>
#include <stdlib.h>

typedef int DataType;

class Vector
{
public:
explicit Vector()
:_pData(new DataType[3])
,_capacity(3)
,_size(0)
{}

//n个值为data的数据
explicit Vector(size_t n, const DataType& data = DataType())
:_size(0)
{
DataType* temp = new DataType
;

for(size_t idx=0; idx<n; idx++)

{
*(temp+idx) = data;
++ _size;
_CheckCapacity();
}
}
Vector(const Vector& v)
:_pData(new DataType[v._pData])
,_size(v._size)
,_capacity(v._capacity)
{
for(size_t idx=0; idx<_size; idx++)

{
_pData[idx] = v._pData[idx];
}
}

Vector& operator=(const Vector& v)
{
if(this != &v)
{
if(_capacity < v._size)
{
DataType * pTemp = new DataType[v._capacity];
delete[] _pData;
_pData = pTemp;
_size = v._size;
_capacity = v._capacity;
}
}
return *this;
}

~Vector()
{
if(NULL != _pData)
{
delete[] _pData;
_pData = NULL;
_capacity = 0;
_size = 0;
}
}

void PushBack(const DataType& data)
{
_CheckCapacity();
_pData[_size] = data;
++_size;
}

void PopBack()
{
assert(0 != _size);
_size--;
}
void Insert(size_t pos, const DataType& data)
{
_CheckCapacity();
size_t count = _size-pos;
int i = 0;
while(count)
{

_pData[_size-i] = _pData[_size-i-1];

i++;
count--;
}
_pData[pos] = data;
_size++;
}
void Erase(size_t pos)
{
assert(0 != _size);
assert(pos < _size);
size_t count = _size-pos-1;
int i = 0;
while(count)
{
_pData[pos+i] = _pData[pos+i+1];
i++;
count--;
}
_size--;
}

void Assign(size_t n, const DataType& data)
{
_size = 0;
DataType* temp = new DataType
;

for(size_t idx=0; idx<n; idx++)

{
*(temp+idx) = data;
++ _size;
_CheckCapacity();
}
}

int Find(const DataType& data)
{
for(int idx=0; idx<_size; idx++)
{
if(_pData[idx] == data)
{
return idx;
}
}
return -1;
}

DataType& Front()
{
return _pData[0];
}

const DataType& Front()const
{
return _pData[0];
}

DataType& Back()
{
return _pData[_size-1];
}

const DataType& Back()const
{
return _pData[_size-1];
}

DataType& operator[](size_t index)
{
assert(index<_size);
return _pData[index];
}

const DataType& operator[](size_t index)const
{
assert(index<_size);
return _pData[index];
}

DataType& At(size_t index)
{
assert(index<_size);
return _pData[index];
}

const DataType& At(size_t index)const
{
assert(index<_size);
return _pData[index];
}

size_t Size()const
{
return _size;
}

size_t Capacity()const
{
return _size;
}

bool Empty()const
{
if(_size == 0)
{
return true;
}
return false;
}

void ReSize(size_t n, const DataType& data = DataType())
{
if(_size > n)
{
size_t count = _size-n;
while(count)
{
_size--;
count--;
}
}
else
{
size_t count = n-_size;
while(count)
{
_CheckCapacity();
_pData[_size] = data;
++_size;
count--;
}
}
}

void Clear()
{
_size = 0;
}

private:
void _CheckCapacity()   //扩容
{
if(_size >= _capacity)
{
DataType *pTemp = new DataType[_capacity*2];
for(size_t idx=0; idx<_size; idx++)
{
pTemp[idx] = _pData[idx];
}
delete[] _pData;
_pData = pTemp;
_capacity *= 2;
}
}

private:
DataType* _pData;
size_t _capacity;
size_t _size;
};