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[n];

		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[n];

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