模版实现动态顺序表

#include<iostream>
using namespace std;
#include<assert.h>
#pragma warning(disable:4018)


template<typename T>
class SeqList
{
public:
	SeqList();
	~SeqList();
	SeqList(const SeqList<T>& s);
	SeqList<T>& operator=(SeqList<T> s);
public:
	void Pushback(const T& x);
	void PopBack();
	void PushFront(const T& x);
	void PopFront();
	void Insert(size_t pos, const T& x);
	void Erase(size_t pos);
	int Find(const T& x);
	void PrintSeqList();
protected:
	void  _CheckCapacity()
	{
		if (_size >= _capacity)
		{
			_capacity = 2 * _capacity + 3;
			//_array = (T*)realloc(_array, sizeof(T)*_capacity);//记住类型转换
			T* tmp = new T[_capacity];
			if (_array)
			{
				//memcpy(tmp, _array, sizeof(T)*_size);
				for (size_t i = 0; i < _size; ++i)
				{
					tmp[i] = _array[i];
				}
			}
			delete[] _array;
			_array = tmp;
		}
	}
private:
	T* _array;
	int _size;
	int _capacity;
};


template<typename T>
SeqList<T>::SeqList()
	:_array(NULL)
	, _size(0)
	, _capacity(0)
{}

template<typename T>
SeqList<T>::~SeqList()
{
	if (_array)
	{
		//free(_array);
		delete[] _array;
	}
}

template<typename T>
SeqList<T>::SeqList(const SeqList<T>& s)
{
	_array = new T[s._size];
	for (int i = 0; i < s._size; ++i)
	{
		_array[i] = s._array[i];
	}
	_size = s._size;
	_capacity = s._size;
}

template<typename T>
SeqList<T>& SeqList<T>::operator=(SeqList<T> s)
{
	std::swap(_array, s._array);
	std::swap(_size, s._size);
	std::swap(_capacity, s._capacity);
}


template<typename T>
void SeqList<T>::Pushback(const T& x)
{
	_CheckCapacity();
	_array[_size++] = x;
}

template<typename T>
void SeqList<T>::PopBack()//因为_szie为int类型，所以popback很多次也不崩溃
{
	--_size;
}

template<typename T>
void SeqList<T>::PushFront(const T& x)
{
	_CheckCapacity();
	for (int i = _size; i >= 1; --i)
	{
		_array[i] = _array[i - 1];
	}
	_array[0] = x;
	++_size;
}


template<typename T>
void SeqList<T>::PopFront()
{
	for (int i = 1; i < _size; ++i)
	{
		_array[i - 1] = _array[i];
	}
	--_size;
}

template<typename T>
void SeqList<T>::Insert(size_t pos, const T& x)
{
	assert(pos >= 0 && pos <=_size);

	for (int i = _size; i>pos; --i)
	{
		_array[i] = _array[i - 1];
	}
	_array[pos] = x;
	++_size;

}

template<typename T>
void SeqList<T>::Erase(size_t pos)
{
	assert(pos >= 0 && pos < _size);
	for (int i = pos; i < _size - 1; ++i)
	{
		_array[i] = _array[i + 1];
	}
	--_size;
}

template<typename T>
int SeqList<T>::Find(const T& x)
{
	for (int i = 0; i < _size; ++i)
	{
		if (_array[i] == x)
		{
			return i;
		}
	}
	return -1;
}

template<typename T>
void SeqList<T>::PrintSeqList()
{
	for (int i = 0; i < _size; ++i)
	{
		cout << _array[i] << " ";
	}
	cout << endl;
}