用模板类实现顺序表

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

template<class T>
class Vector
{
private:
	T* _start;
	T* _finish;
	T* _endOfStorage;
private:
	//如果容量小于顺序表的大小，则增容
	void _CheckCapacity()
	{
		size_t oldsize = Size();
		size_t capacity = Capacity();
		if (Size() >= _capacity)
			size_t newcapacity = 2 * capacity + 3;
		//申请新空间
		T* temp = new T[newCapacity];
		//拷贝元素
		memcpy(temp, _start, size*sizeof(T));
		//释放
		if (_start)
		{
			delete[] _start;
			_start = temp;
			_finish = _start + newsize;
			_endOfStorage = _finish;
		}
	}
public:
	Vector()//无参构造函数
	{
		_start = NULL;
		_finish = 0;
		_endOfStorage = 0;
	}
	Vector(const T* array, size_t size)//有参构造函数
	{
		_start = T[size];
		_finish = _start + size;
		_endOfStorage = _start + size;
		assert(NULL != array);
		//易出错
		//memcpy(_start,array,size*sizeof(T));
		//效率低
		for (size_t i = 0; i < size; ++i)
			_start[i] = array[i];
	}
	Vector(const Vector& v)//拷贝构造函数
		:_start(new T[v.Size()])
	{
		_size_t size = v.Size();
		_start = new T[size];
		for (size_t i = 0; i < size; i++)
			_start[i] = v[i];
		_finish = _start + size;
		_endOfStorage = _finish;
	}
	Vector<T>& operator=(const Vector& s)//重载
	{
		if (this != &s)
		{
			T* temp = new T[s._capacity];
			for (size_t i = 0; i < s._size; i++)
				temp[i] = s._data[i];
			delete[] s._data;
			_data = temp;
			_size = s._size;
			_capacity = s._size;
		}
		return *this;
	}
	~Vector()//析构函数
	{
		if (_start != NULL)
		{
			delete[] _start;
		}
		_start = _finish = _endOfStorage = 0;
	}
	size_t Size()const//返回顺序表的长度
	{
		return _finish-_start;
	}
	size_t Capacity()const//返回顺序表的容量
	{
		return _endOfStorage-_capacity;
	}
	void PushBack(const T& d)//尾插
	{
		_CheckCapacity();
		*_finish++ = d;
	}
	void PopBack()//尾删
	{
		--_finish;
	}
	void Insert(size_t pos, const T& d)//在位置pos处插入数值d
	{
		assert(pos <= Size());
		_CheckCapacity();
		//搬元素
		for (size_t i = Size(); i > pos; --i)
			_start[i] = _start[i-1];
		/*for (size_t i = Size()-1 ; i >= pos; --i)
			_data[i+1] = _data[i];*/
		//插入元素d
		_start[pos] = d;
		_finish++;
	}
	void Erase(size_t pos)//删除位置pos的元素
	{
		assert(pos <= Size());
		for (size_t i = pos; i < Size() - 1; i++)
			_start[i] = _start[i + 1];
		_finish--;
	}
	bool Empty()const//判空
	{
		return 0 == Size();
	}
	//实现下标访问
	T& operator[](size_t index)
	{
		return _start[index];
	}
	const T& operator[](size_t index)const
	{
		return _start[index];
	}
	//返回顺序表的第一个元素
	T& Front()
	{
		return _start[0];
	}
	const T& Front()const
	{
		return _start[0];
	}
	//返回顺序表的最后一个元素
	T& Back()
	{
		return _start[Size() - 1];
	}
	const T& Back()const
	{
		return _start[Size() - 1];
	}
	void Resize(size_t newsize, const T& d = T())//将顺序表中的元素个数变成newSize
	{
		size_t oldsize = Size();
		if (oldsize >= newsize)
			_finish = _start + newsize;
		else if (newsize > oldsize && newsize < Capacity())
		{
			for (size_t i = oldsize; i < newsize; i++)
				_start[i] = d;
			_finish = _start + newsize;
		}
		else
		{
			T* temp = newsize;
			//旧空间的元素搬到新空间
			for (size_t i = 0; i < oldsize; i++)
				temp[i] = _start[i];
			//新空间中多出来的空间放d
			for (size_t i = oldsize; i < newsize; i++)
				temp[i] = d;
			//释放旧空间
			delete[] _start;
			_start = temp;
			_finish = _start + newsize;
			_endOfStorage = _finish;
		}
	}
	void clear()//清空
	{
		_finish = _start;
	}
	void Display()//打印
	{
		if (_start == NULL)
			return;
		size_t size = Size();
		size_t capacity = Capacity();
		for (size_t i = 0; i < size; i++)
		{
			cout << _start[i] << " ";
		}
		cout << endl;
	}
};
int main()
{
	int arr[] = { 1, 2, 3, 4, 5 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	Vector<int> s1(arr, sz);
	s1.Display();
	
	s1.PushBack(1);
	s1.PushBack(1);
	s1.PushBack(1);
	s1.PushBack(1);
	s1.Display();

	s1.PushBack(7);//尾插
	s1.Display();

	s1.PopBack();//尾删
	s1.PopBack();
	s1.Display();

	s1.Insert(2, 9);//指定位置插入
	s1.Display();

	s1.Erase(2);//指定位置删除
	s1.Display();

	s1.Resize(6, 10);
	s1.Display();
	s1.Resize(4);
	s1.Display();
	s1.Resize(10);
	s1.Display();

	s1.clear();
	s1.Display();
	system("pause");
	return 0;
}