C++实现动态顺序表

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

#define DataType int

class Seqlist 
{
	friend ostream& operator<<(ostream &_cout,const Seqlist& s);
public:
	Seqlist();
	Seqlist(DataType arr[],size_t size); 
	Seqlist(const Seqlist& s);
	Seqlist& operator=(const Seqlist& s);
	//Seqlist& operator=(Seqlist s);
	~Seqlist();
	
	void PushBack(const DataType& data);
	void PopBack();
	void Insert(size_t pos,const DataType& data);
	void Erase(size_t pos);
	int Find(const DataType& data)const;
	size_t Size()const;
	size_t Capacity()const;
	DataType& Front();
	DataType& Front()const;
	DataType& Back();
	const DataType& Back()const;
	const DataType& operator[](size_t index)const;
	void Clear();
	bool Empty();
	void Resize(size_t size,const DataType& data = 0);

private:
	void CheckCapacity()
	{
		if(_size >= _capacity)
		{
			DataType *newspace = new DataType[2*_capacity];
			size_t i = 0;
			for(i=0; i<_size; i++)
			{
				newspace[i] = _pData[i];
			}

			delete []_pData;
			_pData = NULL;
			_pData = newspace;
			_capacity *= 2;
		}
	}
private:
	size_t _size;
	size_t _capacity;
	DataType* _pData;
};

ostream& operator<<(ostream &_cout,const Seqlist& s)
{
	size_t i = 0;
	for(i=0; i<s._size; i++)
	{
		_cout<<s._pData[i]<<"->";
	}
	_cout<<"end";

	return _cout;
}

//普通版构造函数
Seqlist::Seqlist()
	:_size(0)
	,_capacity(3)
	,_pData(new DataType[_capacity])
{}
//数组版构造函数
Seqlist::Seqlist(DataType arr[],size_t size)
	:_size(size)
	,_capacity(size)
	,_pData(new DataType[size])
{
	方式1:
	//memcpy(_pData,arr,size*sizeof(DataType));
	
	//方式二:
	size_t i = 0;
	for(i=0; i<size; i++)
	{
		_pData[i] = arr[i];
	}
}
//普通版本的拷贝构造函数
Seqlist::Seqlist(const Seqlist& s)
	:_pData(new DataType[s._capacity])
	,_capacity(s._capacity)
	,_size(s._size)
{
	size_t i = 0;
	for(i=0; i<_size; i++)
	{
		_pData[i] = s._pData[i];
	}
}
简洁版的拷贝构造函数
//Seqlist::Seqlist(const Seqlist& s)
//	:_pData(NULL)
//	,_size(0)
//	,_capacity(0)
//{
//	Seqlist temp(s._pData,_capacity);
//	temp._size = s._size;
//	swap(*this,temp);
//}
//普通版的赋值运算符重载
Seqlist& Seqlist::operator=(const Seqlist& s)
{
	if(this != &s)
	{
		DataType* temp = _pData;//保存原地址
		_pData = new DataType[s._capacity];
		_size = s._size;
		_capacity = s._capacity;
		delete []temp;
		size_t i = 0;
		for(i=0; i<s._size; i++)
		{
			_pData[i] = s._pData[i];
		}
	}
	
    return *this;
}
//简洁版的赋值运算符重载
//Seqlist& Seqlist::operator=(Seqlist s)
//{
//	swap(*this,s);
//	return *this;
//}
Seqlist::~Seqlist()
{
	if(NULL != _pData)
	{
		delete []_pData;
		_pData = NULL;
		_capacity = 0;
		_size = 0;
	}
}

void Seqlist::PushBack(const DataType& data)
{
	assert(_pData);
	CheckCapacity();
	_pData[_size] = data;
	_size++;
}
void Seqlist::PopBack()
{
	assert(_pData);
	if(Empty())
	{
		assert(false);
		return;
	}
	_size--;
}
void Seqlist::Insert(size_t pos,const DataType& data)//在pos之后插入数据data
{
	assert(pos>=0 && pos<_size);
	CheckCapacity();
	size_t i = 0;
	for(i=_size; i>pos; i--)
	{
		_pData[i] = _pData[i-1];
	}
	_pData[pos] = data;
	_size++;
}
void Seqlist::Erase(size_t pos)
{
	assert((pos>=0) && (pos<_size));
	if(_size == 0)
		return;
	else
	{
		size_t i = 0;
		for(i=pos; i<_size-1; i++)
		{
			_pData[i] = _pData[i+1];
		}
		_size--;
	}
}
int Seqlist::Find(const DataType& data)const
{
	size_t i = 0;
	for(i=0; i<_size; i++)
	{
		if(_pData[i] == data)
			return i;
	}
	return -1;
}
size_t Seqlist::Size()const
{
	return _size;
}
size_t Seqlist::Capacity()const
{
	return _capacity;
}
DataType& Seqlist::Front()
{
	assert(_size > 0);
	return _pData[0];
}
DataType& Seqlist::Front()const
{
	assert(_size > 0);
	return _pData[0];
}
DataType& Seqlist::Back()
{
	assert(_size > 0);
	return _pData[_size-1];
}
const DataType& Seqlist::Back()const
{
	assert(_size > 0);
	return _pData[_size-1];
}
const DataType& Seqlist::operator[](size_t index)const
{
	return _pData[index];
}
void Seqlist::Clear()
{
	if(NULL != _pData)
	{
		delete []_pData;
		_size = 0;
		_capacity = 0;
	}
}
bool Seqlist::Empty()
{
	return _size==0;
}
void Seqlist::Resize(size_t size,const DataType& data)
{
	if(size > _size)
	{
		size_t temp = _size;
		_size = size;
		CheckCapacity();
		size_t i = 0;
		for(i=temp; i<size; i++)
		{
			_pData[i] = data;
		}
	}
	if(size > _size)
	{
		_size = size;
	}
}

void Funtest()
{
	int arr[5] = {0};
	Seqlist s1;
	Seqlist s2(arr,5);
	s1.PushBack(1);
	s1.PushBack(2);
	s1.PushBack(3);
	s1.PushBack(4);
	cout<<s1<<endl;
	s1.PopBack();
	cout<<s1<<endl;
	s1.Insert(1,5);
	cout<<s1<<endl;
	s1.Erase(1);
	cout<<s1<<endl;
	int ret = s1.Find(2);
	if(ret == -1)
	cout<<"未找到元素"<<endl;
	else
	cout<<ret<<endl;
	ret = s1.Size();
	cout<<ret<<endl;
	ret = s1.Capacity();
	cout<<ret<<endl;
	ret = s1.Back();
	cout<<ret<<endl;
	ret = s1.Front();
	cout<<ret<<endl;
	bool r = s1.Empty();
	cout<<r<<endl;
	s1.Resize(7,6);
	cout<<s1<<endl;
	s1.Resize(2);
	cout<<s1<<endl;
	s2 = s1;
	cout<<s2<<endl;
}

int main()
{
	Funtest();
	system("pause");
	return 0;
}