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

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

#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;
}

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

最后

以上就是开心翅膀为你收集整理的用模板类迭代器实现顺序表的全部内容，希望文章能够帮你解决用模板类迭代器实现顺序表所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。