c++(模板类)实现顺序表

#pragma once
#include <iostream>
#include <string>
#include <assert.h>
using namespace std;
template<typename T>
class SeqList
{
public:
	SeqList()
		:_a(NULL)
		,_capacity(0)
		,_size(0)
	{} 

	SeqList(const SeqList<T>& s)
		:_size(s._size)
		,_capacity(s._capacity)
		,_a(new T[s._capacity])
	{ 
		 for (size_t i=0;i<_capacity;i++)
		 {
			 _a[i]=s._a[i];
		 }	 
	}
	SeqList<T>& operator= (SeqList<T> s)
	{ 
		if(this!=&s)
		{
			delete _a;
		_a=new T[s._capacity];
		for (size_t i=0;i<s._size;i++)
		{
			_a[i]=s._a[i];
		}
		_capacity=s._capacity;
		_size=s._size;}

		return *this;
	} 
	~SeqList()
	{
		if (_a)
		{
			delete[] _a;
			//free(_a);
			_size = _capacity = 0;
			_a=NULL;
		}
		
	 
	}

	void PushBack(const T& x)
	{
		_CheckCapacity();

		_a[_size] = x; //?
		++_size;
	}

	void PopBack()
	{
		if(_size > 0)
			--_size;
	}

	T& Back()
	{
		assert(_size > 0);
		return _a[_size-1];
	}
	 	size_t Size()
	{
		return _size;
	}

	bool Empty()
	{
		return _size == 0;
	}	 
	void PushFront(const T& x)
	{
		_CheckCapacity();
		size_t end= _size;
		while (end-->=1)
		{
			_a[end+1]=_a[end];
		}
		_a[0]=x;
		++_size;
	}
	void popFront()
	{
		if (_size==0)
		{
			return;
		}
		else	if(_size > 0)
		{
			--_size;
			_a[_size]=_a[_size+1];
		}
			   
	}
 
	void    Print()
	{
		for (size_t i = 0; i < _size; ++i)
		{
			cout<<_a[i]<<" ";
		}
		cout<<endl;
	}

protected:
	void _CheckCapacity()
	{
		if (_size >= _capacity)
		{
			 
			_capacity = _capacity*2+3;
			T* tmp = new T[_capacity];
			if (_a)
			{
				// 优化
				//memcpy(tmp, _a, sizeof(T)*_size);    //若模板类是内置类型或string字符串小于16时使用memcpy完全可以，
				                                       //但是当字符串大于15时，这种方式就会出现问题，因为此时的数据
				                                        //就不是存放于buf中了，而是用ptr指针指向一个空间保存数据，
				                                       //因为memcpy是值拷贝，所以现在会将ptr的地址拷到新的ptr空间，
				                                      //此时是两个指针指向同一块空间，拷贝完成后将就得空间释放时，
				                                      //新的ptr就变成了野指针，所以程序崩溃。
				for (size_t i = 0; i < _size; ++i)
				{
					tmp[i] = _a[i];
				}
				delete[] _a;
			}

			_a = tmp;
		}
	}
 
protected:
	T* _a;
	size_t _size;
	size_t _capacity;
};
// Push / Pop
void TestSeqList1()
{
	SeqList<int> s1;
	s1.PushBack(1);
	s1.PushBack(2);
	s1.PushBack(3);
	s1.PushBack(4);
	
	s1.Print();


	s1.PopBack();
	s1.PopBack();
	s1.PopBack();
	s1.PopBack();
	s1.PopBack();
	s1.Print();
}
// 拷贝、复制运算符的重载
void TestSeqList2()
{
	SeqList<int> s1;
	s1.PushBack(1);
	s1.PushBack(2);
	s1.PushBack(3);
	s1.PushBack(4);
	s1.Print();
	
	SeqList<int> s2(s1);
	s2.Print();

	SeqList<int> s3;

	s3 = s2;
	s3.Print();
}

void TestSeqList3()
{
	// 深层次的深浅拷贝
	SeqList<string> s1;
	s1.PushBack("11111");
	s1.PushBack("222222222");
	s1.PushBack("33");
	s1.PushBack("4444444444444444444444444444444444444444444444 ");
	s1.PushBack("33");
	s1.PushBack("33");
	s1.PushBack("33");
	s1.PushBack("33");
	s1.PushBack("33");

	s1.PushBack("33");

	s1.Print();
}
void TestSeqList4()
{    
	SeqList< int> s4;
	s4.PushFront(1);
	 s4.PushFront(1);
	 s4.popFront();
	 s4.popFront();
	 s4.popFront();
	 s4.Print();
}

#include "SeqList.h"
int main()
{
   TestSeqList1();
    TestSeqList2();
   TestSeqList3();
   TestSeqList4();
 
   return 0;
}