C++实现顺序表模板

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


template<class T>
class vector{
public:
	vector()
		: _Data(new T[3])
		, _MaxSpace(3)
		, _Cur(0)
	{}

	vector(T* arr,size_t s)
		: _Data(new T[s])
		, _MaxSpace(s)
		, _Cur(s)
	{
		for (size_t i = 0; i < _Cur; ++i){
			_Data[i] = arr[i];
		}
	}

	vector(const vector<T>& v);

	vector<T>& operator=(const vector<T>& v);

	~vector();

	T& operator[](size_t index);

	const T& operator[](size_t index)const;

	T& Front();

	const T& Front() const;

	T& Back();

	const T& Back() const;

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

	void PushBack(const T& data);

	void PopBack(const T& data);

	void Insert(size_t pos, T data);

	void Erase(size_t pos);

	void Clear();

	void Print();

	size_t Cur()const
	{
		return _Cur;
	}

	size_t Maxspace()const
	{
		return _Maxspace;
	}

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

	void MaxSpace()
	{
		if (_Cur >= _MaxSpace){
			size_t newMaxSpace = _MaxSpace * 2;
			T* temp = new T[newMaxSpace];
			for (size_t i = 0; i < _Cur; ++i){
				temp[i] = _Data[i];
			}
			delete _Data;
			_Data = temp;
			_MaxSpace = newMaxSpace;
		}
	}

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

template<class T>
vector<T>::vector(const vector<T>& v)
{
	_Data = new T[v._Cur];
	_MaxSpace = v._Cur;
	_Cur = v._Cur;
	for (size_t i = 0; i < _Cur; ++i){
		_Data[i] = v._Data[i];
	}
}

template<class T>
vector<T>& vector<T>::operator=(const vector<T>& v){
	_Data = new T[v._Cur];
	_MaxSpace = v._Cur;
	_Cur = v._Cur;
	for (size_t i = 0; i < _Cur; ++i){
		_Data[i] = v._Data[i];
	}
	return *this;
}

template<class T>
vector<T>::~vector(){
	if (_Data){
		delete _Data;
		_Data = NULL;
		_MaxSpace = 0;
		_Cur = 0;
	}
}

template<class T>
T& vector<T>::operator[](size_t index){
	assert(_Data);
	return _Data[index];
}

template<class T>
const T& vector<T>::operator[](size_t index) const{
	assert(_Data);
	return _Data[index];
}

template<class T>
T& vector<T>::Front(){
	return _Data[0];
}

template<class T>
const T& vector<T>::Front() const{
	return _Data[0];
}

template<class T>
T& vector<T>::Back(){
	return _Data[_Cur-1];
}

template<class T>
const T& vector<T>::Back() const{
	return _Data[_Cur-1];
}

template<class T>
void vector<T>::ReSize(size_t newCur, T data = T()){
	if (newCur < _Cur){
		_Cur = newCur;
	}
	else if (newCur>_Cur&&newCur < _MaxSpace){
		for (size_t i = 0; i < _Cur; ++i){
			_Data[i] = data;
		}
	}
	else{
		T* temp = new T[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;
	}
}

template<class T>
void vector<T>::PushBack(const T& data){
	MaxSpace();
	_Data[_Cur++] = data;
}

template<class T>
void vector<T>::PopBack(const T& data){
	assert(_Data);
	--_Cur;
}

template<class T>
void vector<T>::Insert(size_t pos, T data){
	if (pos > _Cur)
		return;
	MaxSpace();
	for (size_t i = _Cur; i > pos; --i){
		_Data[i+1] = _Data[i];
	}
	_Data[pos] = data;
	++_Cur;
}

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

template<class T>
void vector<T>::Clear(){
	_Data = NULL;
	_MaxSpace = 0;
	_Cur = 0;
}

template<class T>
void vector<T>::Print()
{
	if (_Cur > 0)
	{
		for (size_t i = 0; i < _Cur; ++i)
			cout << _Data[i] << " ";
		cout << endl;
	}
	else
		cout << "顺序表为空" << endl;
}

void FunTest1(){
	int array[10] = { 1, 2, 7, 4, 5, 6, 7, 8, 9, 10 };
	vector<int> s1(array, sizeof(array) / sizeof(array[0]));
	vector<int> s2(s1);
	vector<int> 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(2);
	s1.Print();
	s1.Empty();
	s1.Print();
}

void FunTest2(){
	char* arr = "sdjfhu";
	int sz = strlen(arr);
	vector<char> s1(arr, sz);
	vector<char> s2;
	s2 = s1;
	//s1.Print();
	//s1.PushBack('a');
	//s1.Print();
	//s1.PopBack('a');
	//s1.Print();
	//s1.Insert(3, 'o');
	//s1.Print();
	//s1.Erase(1);
	//s1.Print();
	//s1.Clear();
	//s1.Print();
	s2.Print();
	s2.PushBack('a');
	s2.Print();
	s2.PopBack('a');
	s2.Print();
	s2.Insert(3, 'o');
	s2.Print();
	s2.Erase(1);
	s2.Print();
	/*s2.Clear();
	s2.Print();*/
	cout << s2.Front() << endl;
	cout << s2.Back() << endl;
}


int main(){
	//FunTest1();
	FunTest2();
	return 0;
}