顺序表-----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;
}

以上为动态顺序表C++实现，即在类中实现