顺序表-----C++实现

#include<assert.h>

#include<stdio.h>
#include<stdlib.h>
#include<iostream>
using namespace std;
#define DataType int

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

Vector(const Vector& v)
:_pData(new DataType[v._capacity])
,_capacity(v._capacity)
,_size(v._size)
{
//memcpy(_pDate,v._pDate);
for(size_t idx=0;idx<_size;idx++)
{
_pData[idx]=v._pData[idx];
}
}

Vector& operator=(const Vector& v)
{
DataType* pTemp=new DataType[v._capacity];
for(size_t idx=0;idx<v._capacity;idx++)
{
pTemp[idx]=v._pData[idx];
}
delete[] _pData;
_pData=pTemp;
_capacity=v._capacity;
_size=v._size;
return *this;
}

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

void PopBack()
{
//assert(0 == _size);
if(_size==0)
{
return;
}
--_size;
}

void Insert(size_t pos, const DataType& data)
{	if((_size-1)==pos)
{
PushBack(data);
}
else
{
_size+=1;
_CheckCapacity();
for(size_t idx=_size-1;idx>pos;idx--)
{
_pData[++idx]=_pData[idx];
}
_pData[pos+1]=data;
}
}

void Erase(size_t pos)
{
size_t ret=_size;
if((--ret)==pos)
{
PopBack();
}else if(0==pos)
{
DataType* pTemp=new int[_capacity];
for(size_t idx=1;idx<_size;idx++)
{
pTemp[idx-1]=_pData[idx];
}
delete[] _pData;
_pData =pTemp;
--_size;
}
else
{
for(size_t idx=pos+1;idx<_size;idx++)
{
_pData[idx-1]=_pData[idx];
}
--_size;
}
}

void Assign(size_t n, const DataType& data)
{
_size=n;
_CheckCapacity();

DataType* pTemp=new DataType[_capacity];
for(size_t idx=0;idx<n;idx++)
{
pTemp[idx]=data;
}
delete[] _pData;
_pData = pTemp;

}

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

////////访问元素//////////////////
DataType& Front()
{
assert(_pData);
return _pData[0];
}
const DataType& Front()const
{
assert(_pData);
return _pData[0];
}
DataType& Back()
{
assert(_pData);
return _pData[_size-1];
}
const DataType& Back()const
{
assert(_pData);
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 _capacity;
}
bool Empty()const
{
if(0==_size)
{
return true;
}
return false;
}
void ReSize(size_t n, const DataType& data = DataType())
{
if(n<=_size)
{
_size = n;
}
else
{
size_t ret = _size;
_size = n;
_CheckCapacity();
for(size_t idx=ret;idx<n;idx++)
{
_pData[idx] = data;
}
}
}
void Clear()
{
_size=0;
}

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

void funtest()
{
Vector v1;
v1.PushBack(1);
v1.PushBack(2);
v1.PushBack(3);
int a=3;
int ret=v1.Find(a);
/*v1.Erase(1);*/
//v1.Insert(2,7);
//v1.PopBack();
/*v1.ReSize(5,10);
int ret = v1.At(4);*/
}
int main()
{
funtest();
return 0;
}