C++模板类实现Vector

定义类模板（class template）

在定义的类模板中，使用模板形参作为类型或值的占位符，在使用类时再提供具体的类型或值。

代码实现：
1、

Vector<int>
Vector<char>

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

template<typename T>
class Vector
{
public:
    Vector()//构造
        :_start(0)
        , _finish(0)
        , _endOfStorage(0)
    {}

    Vector(const T* array, size_t size);//带参构造函数声明

    Vector(const Vector<T>& v)//拷贝构造
    {
        size_t size = v.Size();
        T* temp = new T[size];
        assert(temp);
        for (size_t i = 0; i < size; i++)
        {
            temp[i] = v[i];
        }
        delete[] _start;
        _start = temp;

        _finish = _start + size;
        _endOfStorage = _finish;
    }
    Vector& operator=(const Vector<T>& s)//赋值运算符重载
    {
        if (this != &s)
        {
            _start = new T[1];
            Vector temp(s);
            swap(_start, temp._start);
        }
        return *this;
    }
    ~Vector()
    {
        if (_start)
        {
            delete[] _start;
            _start = _finish = _endOfStorage = 0;
        }
    }
    void Display()
    {
        size_t size = Size();
        for (size_t i = 0; i < size; i++)
        {
            cout << _start[i];
        }
        cout << endl;
    }
    ///Modify
    void PushBack(const T& data)//尾插
    {
        CheckCapacity();//增容函数
        *_finish++ = data;
    }
    void PopBack()//尾删
    {
        --_finish;
    }
    void Insert(size_t pos, const T& data)//任意位置的插入
    {
        size_t size = Size();
        assert(pos <= size && pos >= 0);
        CheckCapacity();
        for (size_t i = size; i > pos; i--)
        {
            _start[i] = _start[i - 1];
        }
        _start[pos] = data;
        _finish++;
    }
    void Erase(size_t pos)//任意位置的删除
    {
        size_t size = Size();
        assert(pos < size && pos >= 0);

        for (size_t i = pos; i < size - 1; i++)
        {
            _start[i] = _start[i + 1];
        }
        _finish--;
        /*if (pos = size - 1)
        _finish--;*/
    }

    //capacity/ 
    size_t Size()const//顺序表元素个数
    {
        return _finish - _start;
    }
    size_t Capacity()const//顺序表容量
    {
        return _endOfStorage - _start;
    }
    bool Empty()const//判空
    {
        return _start == _finish;
    }
    void Resize(size_t newSize, const T& data = T())//元素个数改变到newSize
    {
        size_t oldsize = Size();
        size_t capacity = Capacity();
        if (newSize <= oldsize)
        {
            _finish = _start + newSize;
        }
        else if (oldsize < newSize&&newSize <= capacity)
        {
            //*(_finish++) = data;
            for (size_t i = oldsize; i < newSize; i++)
            {
                _start[i] = data;
            }
            _finish = _start + newSize;
        }
        else
        {
            T* temp = new T[newSi