简单的顺序表中的一些函数以及一些简单的测试

编译环境是vs2012

#include<windows.h>
#include<assert.h>
#include<iostream>
using namespace std;
/*struct Seqlist
{
	int *_array;
	size_t _size;
	size_t _capacity;

};


void InitSeqlist(Seqlist * q)
{
	assert(q);
	q->_array = new int[3];
	q->_capacity = 3;
	q->_size = 0;
}

void PushBack(SeqList *q,int data)
{
	assert(q);
	q->_array[q->_size++] = data;
}
*/


typedef int DataType;
class SeqList
{
public:
	SeqList()
		:_array(new DataType[3])
		, _capacity(3)
	    , _size(0)
		{}
		SeqList(DataType *array, size_t size)
			:_array(new DataType[size])
			, _capacity(size)
			, _size(size)
		//把数组里的东西搬到顺序表里
		{
			for (size_t i = 0; i < size; i++)
				_array[i] = array[i];
			//memcpy(_array, array, size*sizeof(array[0]));
		}

		SeqList(const SeqList&s);
		SeqList& operator=(const SeqList& s);
		~SeqList()
		{
			if (_array)
			{
				delete[] _array;
				_size = 0;
				_capacity = 0;
			}
		}





		void PushBack(int data)
		{
			_CheckCapacity();
			_array[_size++] = data;
		}


		void PopBack()
		{
			assert(_size);
			--_size;
		}


		void PushFront()//头插和头删效率太高，没有必要实现
		{

		}
		void PopFront()
		{

		}


		void Insert(DataType pos,DataType data)//任意位置插入
		{
			assert(pos <= _size && pos > 0);
			
			_CheckCapacity();
			for (int i = _size - 1; i >= (int)pos; --i)
				_array[i + 1] = _array[i];//后一个搬到前一个
			
			_array[pos] = data;
			_size++;
		}



		void Erase(DataType pos)//任意位置删除
		{
			assert(pos < _size);
			for (int i = pos+1; i < _size; ++i)
				_array[i-1] = _array[i];
			_size--;
		}


		int Size()const
		{
			return _size;
		}

		int Capacity()const
		{
			return _capacity;
		}

		bool empty()const
		{
			return 0 == _size;
		}



		DataType& operator[](int index)//返回的是所存对象的引用，
		{
			return _array[index];
		}

		const DataType& operator[](int index)const
		{
			return _array[index];
		}

		DataType& Front()
		{
			return _array[0];
		}

		const DataType& Front()const
		{
			return _array[0];
		}

		DataType& Back() const
		{
			return _array[_size - 1];
		}

		void Clear()//清空顺序表
		{
			_size = 0;
		}

		//把顺序表中元素个数改变到newsize
		//1. newsize<=_size
		//2._size<newsize<_capacity
		//3.newsize>_capacity  需要增容
		void Resize(int newsize,const DataType& data = DataType()) 
		{
			if (newsize <= _size)
				_size = newsize;
			else if (_size < newsize && newsize < _capacity)
			{
				for (int i = _size; i < newsize; i++)
					_array[i] = data;
			}
			else
			{
				DataType* temp = new DataType[newsize];
				//旧空间中的内容搬到新空间
				for (int i = 0; i < _size; i++)
					temp[i] = _array[i];
				//多出的空间放data
				for (int i = _size; i < newsize; i++)
					temp[i] = data;

				delete temp;
				_array = temp;
				_size = newsize;
				_capacity = newsize;
			}
		}


		/*friend iostream& operator<<(ostream& _cout, const SeqList& s)
		{
			for (size_t i = 0; i < s.Size(); i++)
			{
				cout << s._array[i] << "";
			}
			return _size;
		}
		 */

private:
	void _CheckCapacity()
	{
		if (_size == _capacity)
		{

			//开辟新空间
			DataType* temp = new DataType[(_capacity << 1)];
			//拷贝元素
			for (size_t i = 0; i < _size; i++)
				temp[i] = _array[i];
			//释放就空间
			delete[] _array;
			_array = temp;
			_capacity <<= 1;
		}
	}
private:
    DataType*_array;
	size_t _size;
	size_t _capacity;
};



void FunTest()
{
	int array[] = { 1, 2, 3, 4, 5 };
	SeqList s1(array, sizeof(array) / sizeof(array[0]));
	cout << s1 << endl;
	cout << s1.Size() << endl;
	cout << s1.Capacity() << endl;

	s1.PushBack(6);
	cout << s1 << endl;
	cout << s1.Size() << endl;
	cout << s1.Capacity() << endl; 

	s1.PopBack();
	cout << s1 << endl;
	cout << s1.Size() << endl;
	cout << s1.Capacity() << endl; 
	
	s1.Insert(0, 0);
	cout << s1 << endl;
	cout << s1.Size() << endl;
	cout << s1.Capacity() << endl;

	s1.Erase(0);
	cout << s1 << endl;
	cout << s1.Size() << endl;
	cout << s1.Capacity() << endl;

}

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