vector容器的迭代器实现

#include <iostream>

using namespace std;
template<typename T>
class vector
{
public:
    vector(int size = 10)
    {
        _first = new T[size];
        _last = _first;
        _end = _first + size;
    }
    ~vector()
    {
        delete[]_first;
        _first = _last = _end = nullptr;
    }
    vector(const vector<T> &src)
    {
        int size = src._end - src.first;
        _first = new T[size];
        int len = src._last - src._first;
        for (int i = 0; i < len; i++)
        {
            _first[i] = src._first[i];
        }
        _last = _first + len;
        _end = _first + size;
    }
    vector<T>& operator=(const vector<T> &src)
    {
        if (this == &src)
        {
            return *this;
        }
        delete[]_first;
        int size = src._end - src.first;
        _first = new T[size];
        int len = src._last - src._first;
        for (int i = 0; i < len; i++)
        {
            _first[i] = src._first[i];
        }
        _last = _first + len;
        _end = _first + size;
        return *this;
    }
    void push_back(const T val)//向容器末尾添加元素
    {
        if (full())
        {
            expand();
        }
        *_last++ = val;
    }
    void pop_back()//从容器末尾删除元素
    {
        if (empty())
        {
            return;
        }
        --_last;
    }
    T back()const//返回容器末尾的元素值
    {
        return *(_last - 1);
    }
    bool full()const
    {
        return _last == _end;
    }
    bool empty()const
    {
        return _first == _last;
    }
    int size()const
    {
        return _last - _first;
    }
    const T& operator[](int index) 
    {
        if (index < 0 || index >= size())
        {
            throw "OutOfRangeException";
        }
        return _first[index]; 
    }
    //迭代器一般实现成容器的嵌套类型
    class iterator
    {
    public:
        iterator(T *p = nullptr) :_ptr(p) {}
        bool operator!=(const iterator& it)const
        {
            return _ptr != it._ptr;
        }
        void operator++()
        {
            ++_ptr;
        }
        T& operator*()
        {
            return *_ptr;
        }
        const T& operator*()const
        {
            return *_ptr;
        }
    private:
        T *_ptr;
    };
    iterator begin()
    {
        return iterator(_first);
    }
    iterator end()
    {
        return iterator(_last);
    }
private:
    T *_first;//指向数组起始位置
    T *_last;//指向数组中有效元素的后继位置
    T *_end;//指向数组空间的后继位置
    void expand()
    {
        int size = _end - _first;
        T *_ptmp = new T[2 * size];
        for (int i = 0; i < size; i++)
        {
            _ptmp[i] = _first[i];
        }
        delete[]_first;
        _first = _ptmp;
        _last = _first + size;
        _end = _first + 2 * size;
    }
};

int main()
{
    vector<int> vec;
    for (int i = 0; i < 20; i++)
    {
        vec.push_back(rand() % 100+1);
    }
    auto it = vec.begin();
    int size = vec.size();
    for (int i = 0; i < size; ++i)
    {
        cout << vec[i] << " ";
    }
    cout << endl;
    for (; it != vec.end(); ++it)
    {
        cout << *it<<" ";
    }
    cout << endl;
    return 0;
}

运行结果：