用模板类迭代器实现顺序表

之前我用模板类实现了顺序表，但是发现如遇到字符串的还是得重新重载字符串，但是在使用迭代器之后，则可以将顺序表中的东西一一遍历一次。
具体实现如下：

#pragma once
//#include"Vector.h"
#include<iostream>
#include<string>
#include<assert.h>
using namespace std;
template<class T>
struct Vector
{
public:
    typedef T* Iterator;//迭代器
    typedef T*constIterator;
public:
    Vector()//构造函数
        : _start(0)
        , _finish(0)
        , _endOfStorage(0)
    {}
    Vector(const T* array, size_t size)//带参数的构造函数
        :_start(new T[size])
        , _finish(_start + size)
        , _endOfStorage(_start + size)
    {
        for (size_t i = 0; i < size; i++)  //效率低，但不易出错。
        {
            _start[i] = array[i];
        }
    }
    Vector(const Vector& v)//拷贝构造函数
    {
        size_t size = v.Size();
        _start = new T[size];
        for (size_t i = 0; i < size; i++)
        {
            _start[i] = v._start[i];
        }
        _finish = _start + size;
        _endOfStorage = _finish;
    }
    Vector& operator=(const Vector& s)//赋值运算符重载
    {
        size_t size = s.Size();
        if (this != &s)
        {
            T*temp = new T[size];
            for (size_t i = 0; i < size; i++)
            {
                temp[i] = s._start[i];
            }
            delete[]_start;
            _start = temp;
            _finish = _start + size;
            _endOfStorage = _finish;
        }
        return *this;
    }
    ~Vector()//析构函数
    {
        if (_start)
            delete[]_start;
        _start = NULL;
    }
    //////////////Iterator///////////////////////////////// 
    Iterator Begin()   //返回一个当前vector容器中起始元素的迭代器。
    {
        return _start;
    }
    Iterator End()  //返回一个当前vector容器中末尾元素的迭代器。
    {
        return _finish;
    }  
    constIterator  Begin()const
    {
        return _start;
    }
    constIterator  End()const
    {
        return _finish;
    }
    void PushBack(const T& data)//尾插
    {
        _CheckCapacity();
        *_finish = data;
        _finish++;
    }
    void PopBack()//尾删
    {
        assert(_start < _finish)
            _finish--;
    }
    void Insert(size_t pos, const T& data)//指定位置插入
    {
        size_t size = Size();
        assert(pos <= Size());
        _CheckCapacity();
        for (size_t i = size - 1; i >pos; i--)
        {
            _start[i + 1] = _start[i];
        }
        _start[pos] = data;
        _finish++;
    }
    void Erase(size_t pos)//指定位置的删除
    {
        assert(pos < Size());
        for (size_t i = 0; i < Size() - 1; i++)
        {
            _start[i] = _start[i + 1];
        }
        _finish--;
    }

    //////////////////capacity//////////////////////////// 
    size_t Size()const//返回大小
    {
        return _finish - _start;
    }
    size_t Capacity()const//返回容量
    {
        return _endOfStorage - _start;
    }
    bool Empty()const
    {
        return 0 == Size();
    }
    void Resize(size_t newSize, const T& data = T())//扩容函数
    {
        if (newSize < Size())
        {
            _finish = _start + newSize;
        }
        else if ((newSize>Size()) && (newSize <= Capacity()))
        {
            for (size_t i = Size(); i < newSize; i++)
            {
                *_finish = data;
                _finish++;
            }
        }
        else
        {
            T*temp = new T[newSize];
            for (size_t i = 0; i < Size(); i++)
            {
                temp[i] = _start[i];
            }
            for (size_t i = Size(); i < newSize; i++)
            {
                temp[i] = data;
            }
            delete[]_start;
            _start = temp;
            _finish = _start + newSize;
            _endOfStorage = _finish;
        }
    }
    //////////////Acess/////////////////////////// 
    T& operator[](size_t index)
    {
        return _start[index];
    }
    const T& operator[](size_t index)const
    {
        return _start[index];
    }
    T& Front()   //返回当前vector容器中起始元素的引用。
    {
        return _start[0];
    }
    const T& Front()const
    {
        return _start[0];
    }
    T& Back() //返回当前vector容器中末尾元素的引用。
    {
        return *(_finish - 1);
    }
    const T& Back()const
    {
        return *(_finish - 1);
    }
    void Clear()
    {
        _finish = _start;
    }
    friend ostream& operator<<(ostream& _cout, const Vector<T>& v)//输出运算符重载
    {
        Vector<T>::constIterator t1 = v.Begin();
        while(t1!=v.End())
        {
            _cout << *t1 << " ";
            ++t1;
        }
        return _cout;
    }
private:
    void _CheckCapacity()//检查容量与扩容函数
    {
        size_t size = Size();
        size_t oldCapacity = Capacity();
        size_t NewCapacity = 2 * oldCapacity + 3;
        if (size >= oldCapacity)
        {
            T* temp = new T[NewCapacity];
            for (size_t i = 0; i < size; i++)
            {
                temp[i] = _start[i];
            }
            delete[]_start;
            _start = temp;
            _finish = _start + size;
            _endOfStorage = _start + NewCapacity;
        }
    }
    T* _start;
    T* _finish;
    T* _endOfStorage;
};
void test1()
{
    Vector<char> v1;
    v1.PushBack('m');
    v1.PushBack('n');
    v1.PushBack('o');
    v1.PushBack('p');
    //v1.display();
    //Vector<string>v2;
    //cout << v1 << endl;
    cout << v1.Capacity() << endl;
    cout << v1.Size() << endl;
    v1.Resize(6, 'p');
    //v1.display();
    v1.Begin();
    //v1.display();
    v1.Back();
    v1.display();
    int arr[] = { 1, 2, 3, 4 };
    int sz = sizeof(arr) / sizeof(arr[0]);
    Vector<int>v2(arr, sz);
    cout << v2.Capacity() << endl;
}
void test2()
{
    string arr[4] = { string("1111"), string("2222"),
        string("3333"), string("4444") };
    Vector<string>v2(arr, 4);
    cout << v2 << endl;
    v2.Insert(0, string("0000"));
    v2.Insert(v2.Size(), string("5555"));
    cout << v2 << endl;
    v2.Resize(20, string("1234"));
    cout << v2 << endl;
}
int main()
{
    test1();
    test2();
    system("pause");
    return 0;
}

具体的运行界面如下所示：