STL中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(int argc, char *argv[])
{
    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;
}