模拟实现Vector

#include<iostream>
#include<assert.h>
#include<string.h>
#include<algorithm>

using namespace std;
template<class T>
class Vector{
	typedef T* Iterator;
	typedef const T* Const_Iterator;

public:
	//Vector初始容量：0
	//无参构造函数
	Vector()
		:_start(nullptr)
		, _finish(nullptr)
		, _endOfStorage(nullptr)
	{

	}
	//有参构造
	Vector(int num, const T& val = T()) //num 个数 
		:_start(nullptr)
		, _finish(nullptr)
		, _endOfStorage(nullptr)
	{
		_start = new T[num];
		fill(_start, _start + num, val);			//初始化
		_finish = _start + num;
		_endOfStorage = _start + num;
	}
	//拷贝构造      完全相同
	Vector(const Vector<T>& v)
	{
		//深拷贝
		_start = new T[v.Capacity()];
		for (int i = 0; i<v.Size(); i++)
		{
			_start[i] = v[i];
		}
		_finish = _start + v.Size();
		_endOfStorage = _start + v.Capacity();
	}
	//尾部添加元素
	void PushBack(const T& n)
	{
		if (_finish == _endOfStorage)
		{
			reverse(Capacity() + 1);
		}
		*_finish++ = n;
	}
	//尾部删除元素
	void PopBack()
	{
		if (_finish != _start)
		{
			_finish--;
		}
	}
	//扩容
	void reverse(int n)
	{
		//n>capacity
		if (n > Capacity())
		{
			T* newaddr = new T[n];
			int len = Size();
			if (_start)      //如果vector初始化_st有分配空间
			{
				//深拷贝
				for (int i = 0; i<n; i++)
				{
					newaddr[i] = _start[i];
				}
				delete[]_start;     //释放原有空间
			}
			//更新指针
			_start = newaddr;
			_endOfStorage = newaddr + n;
			//_finish = newaddr + newaddr.Size();       创建的为T类型 无法调用Vector<T> 的函数
			_finish = newaddr + len;
		}
	}
	//运算符重载 =
	Vector<T> operator=(Vector<T> &v)
	{
		Vector<T> n(v);
		_start = n._start;
		_finish = n._finish;
		_endOfStorage = n._endOfStorage;
		return  *this;
	}
	//运算符重载 []         可读可写
	T& operator[](int n)
	{
		assert(n>Size());
		return _start + n;
	}
   const T& operator[](int n)const
	{
		assert(n<Size());
		return _start[n];
	}
	//交换函数
	void Swap(Vector<T>& v)
	{
		swap(_start, v._start);
		swap(_finish, v._finish);
		swap(_endOfStorage, v._endOfStorage);
	}
	//判空函数
	bool Empty()
	{
		return _start == _finish;
	}
	//容量
	int Capacity()const
	{
		return _endOfStorage - _start;
	}
	//实际存储量
	int Size()const
	{
		return _finish - _start;
	}
	//迭代器    可读可写
	Iterator begin()
	{
		return _start;
	}
	Iterator end()
	{
		return _finish;
	}
	//迭代器    只读
	Const_Iterator Begin() const
	{
		return _start;
	}
	Const_Iterator End()const
	{
		return _finish;
	}
	//Insert     会导致迭代器失效：增容 开辟新的空间  需要更新迭代器
	void Insert(Iterator pos, const T& val)         //迭代器插入
	{
		assert(pos <= _finish || pos >= _start);
		int len = pos - _start;     //用于更新迭代器
		//检查空间容量
		if (_finish == _endOfStorage)
		{
			//     int newC = 0;
			//     if(_start == nullptr)
			//         newC = 1;
			//     else
			//     {
			//        newC = 2 * Capacity();
			//     }
			int newC = (_start == nullptr ? 1 : Capacity() * 2);
			reverse(newC);
		}
		//更新迭代器    避免迭代器失效
		pos = _start + len;
		Iterator end = _finish;
		while (end > pos)			//边界处理
		{
			*end = *(end - 1);
			--end;
		}
		*pos = val;
		_finish++;
	}
	//删除指定位置元素      不存在增容问题，不存在迭代器失效
	Iterator Erase(Iterator pos)
	{
		assert(pos >= _start || pos <= _finish);
		Iterator begin = pos + 1;
		while (begin < _finish)
		{
			*(begin - 1) = *begin;
			begin++;
		}
		--_finish;
		return pos;
	}
	//重新设置有效字符
	void Resize(size_t n, const T& val = T())
	{
		if (n < Size())
		{
			_finish = _start + n;
		}
		else
		{
			if (n > Capacity())
			{
				reverse(n);
			}
			//新增位置初始化
			while (_finish != _start + n)
			{
				*_finish = val;
				++_finish;
			}
		}

	}
	//析构函数
	~Vector()
	{
		if (_start)
		{
			delete[] _start;
			_start = _finish = _endOfStorage = nullptr;
		}
	}
private:
	T* _start;
	T* _finish;
	T* _endOfStorage;
};

template<class T>
void PrintVector(const Vector<T>& v)
{
	 for(const  &e : v)
	{
	    cout<<e<<"  ";
	 }
	cout << endl;
}