C++实现顺序表

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

typedef int Datatype;

class SeqList{
public:
	SeqList()
		: _Data(new Datatype[3])
		, _MaxSpace(5)
		, _Cur(0)
	{}

	SeqList(Datatype* array,size_t s)
		: _Data(new Datatype[s])
		, _MaxSpace(s)
		, _Cur(s)
	{
		//memcpy(_Data, arr, sizeof(Datatype)*s);
		for (size_t i = 0; i < _Cur; ++i){
			_Data[i] = array[i];
		}
	}

	SeqList(const SeqList& s)
	{
		_Data = new Datatype[s._Cur];
		_MaxSpace = s._Cur;
		_Cur = s._Cur;
		for (size_t i = 0; i < s._Cur; ++i){
			_Data[i] = s._Data[i];
		}
	}

	SeqList& operator=(const SeqList& s)
	{
		if (this != &s){
			_Data = s._Data;
		}
		return *this;
	}

	~SeqList()
	{
		if (_Data){
			delete[] _Data;
			_Data = NULL;
			_MaxSpace = 0;
			_Cur = 0;
		}
	}

	size_t Cur()const
	{
		return _Cur;
	}

	size_t MaxSpace()const
	{
		return _MaxSpace;
	}

	bool Empty()const
	{
		return 0 == _Cur;
	}

	Datatype& operator[](size_t index)
	{
		assert(index < _Cur);
		return _Data[index];
	}

	const Datatype& operator[](size_t index)const
	{
		return _Data[index];
	}

	Datatype& Front()
	{
		return _Data[0];
	}

	const Datatype& Front()const
	{
		return _Data[0];
	}

	Datatype& Back()
	{
		return _Data[_Cur - 1];
	}

	const Datatype& Back()const
	{
		return _Data[_Cur - 1];
	}

	void MaxSpacs()
	{
		if (_MaxSpace <= _Cur){
			size_t NewMaxSpace = _MaxSpace * 2;
			Datatype* temp = new Datatype[NewMaxSpace];
			for (size_t i = 0; i < _Cur; ++i){
				temp[i] = _Data[i];
			}
			delete _Data;
			_Data = temp;
			_MaxSpace = NewMaxSpace;
		}
	}

	void ReSize(size_t newCur, Datatype data = Datatype());

	void PushBack(const Datatype& data);

	void PopBack(const Datatype& data);

	void Insert(size_t pos, Datatype data);

	void Erase(size_t pos);

	void Clear();

	void Print()//打印顺序表
	{
		if (_Cur > 0)
		{
			for (size_t i = 0; i < _Cur; ++i)
				cout << _Data[i] << " ";
			cout << endl;
		}
		else
			cout << "顺序表为空" << endl;
	}


private:
	Datatype* _Data;
	size_t _MaxSpace;
	size_t _Cur;
};

void SeqList::PushBack(const Datatype& data){
	MaxSpacs();
	_Data[_Cur++] = data;
}

void SeqList::PopBack(const Datatype& data){
	assert(data);
	--_Cur;
}

void SeqList::Insert(size_t pos, Datatype data){
	if (pos > _Cur)
		return;
	MaxSpacs();
	for (size_t i = _Cur; i < pos; --i){
		_Data[i] = _Data[i - 1];
	}
	_Data[pos] = data;
	++_Cur;
}

void SeqList::Erase(size_t pos){
	if (pos>_Cur)
		return;
	for (size_t i = pos; i < _Cur; ++i){
		_Data[i] = _Data[i + 1];
	}
	--_Cur;
}

void SeqList::ReSize(size_t newCur, Datatype data){
	if (newCur < _Cur){
		_Cur = newCur;
	}
	else if(newCur>=_Cur&&newCur<_MaxSpace){
		for (size_t i = 0; i < _Cur; ++i){
			_Data[i] = data;
		}
	}
	else{
		Datatype* temp = new Datatype[newCur];
		for (size_t i = 0; i < _Cur; ++i){
			temp[i] = _Data[i];
		}
		for (size_t i = _Cur; i < newCur; ++i){
			temp[i] = data;
		}
		delete[] _Data;
		_Data = temp;
		_MaxSpace = newCur;
		_Cur = newCur;
	}
}

void SeqList::Clear(){
	_Cur = 0;
}

//void FunTest(){
//	int arr[] = { 0, 1, 2, 3, 4 };
//	int sz = sizeof(arr) / sizeof(arr[0]);
//	SeqList s1(arr, sz);
//	s1.PushBack(9);
//	s1.Insert(3, 7);
//
//}


//int main(){
//
//	FunTest();
//	return 0;
//}
int main()
{
	int array[10] = { 1, 2, 7, 4, 5, 6, 7, 8, 9, 10 };
	SeqList s1(array, sizeof(array) / sizeof(array[0]));
	SeqList s2(s1);
	SeqList s3 = s2;
	s1.Print();
	s2.Print();
	s3.Print();
	s1.PushBack(11);
	s1.Print();
	s1.PopBack(2);
	s1.Print();
	s1.Print();
	s1.Insert(4, 15);
	s1.Print();
	s1.Erase(15);
	s1.Print();
	s1.Empty();
	s1.Print();
	return 0;
}