实现一个简单的vector类

vector ---- 序列容器-----可变大小数组

存储：连续存储空间来存储元素
vector是使用动态分配数组来存储它的元素。就时间而言，相对较高
因此，vector占用了更多的存储空间，并且以一种有效的方式动态增长

访问：支持随机访问，访问效率O(1）
采用下标进行访问，与数组访问一样高效
与其他动态序列容器相比，vector访问元素，在末尾添加和删除元素更加高效
大小：vector会分配一些额外的空间，防止一些可能的增长
他的大小会被容器自动处理
并不是每一次元素加入到容器时，都会重新分配大小

vector构造函数：
vector()		无参构造				
vector（size_type n, const value_type& val = value_type()）	构造并初始化n个val
vector (const vector& x); 		拷贝构造
vector (InputIterator first, InputIterator last);	使用迭代器进行初始化构造

代码：

typedef int DataType;

class Vector{
    public:
        Vector()
            :_first(nullptr)
            ,_finish(nullptr)
            ,_endofstorage(nullptr)
        {}

        ~Vector()
        {
            if(_first)
            {
                delete[] _first;
                _first = _finish = _endofstorage = nullptr;
            }
        }

        size_t _size() const
        {
            return _finish - _first;
        }

        size_t _capacity() const{
            return _endofstorage - _first;
        }

        Vector(const Vector& v)
        {
            //只开辟了_size的空间
            _first = new DataType[v._size()];
            _finish = _first + v._size();
            _endofstorage = _first + _size();

            memcpy(_first,v._first,sizeof(DataType)*v._size());
        }

        Vector& operator=(Vector v)
        {
            swap(this->_first,v._first);
            swap(this->_finish,v._finish);
            swap(this->_endofstorage,v._endofstorage);

            return *this;
        }

        void _revers(size_t n)
        {
            if(n > _capacity())
            {
                _expand(n);
            }
        }

        void _resize(size_t n,DataType value)
        {
            if(n < _size())
            {
                _finish = _first + n;
            }
            else
            {
                if(n > _capacity())
                {
                    _expand(n);
                }
                DataType* end = _first + n;
                while(_finish < end)
                {
                    *_finish = value;
                    ++_finish;
                }
            }

        }

        DataType& operator[](size_t pos)
        {
            return _first[pos];
        }

        void _push_back(DataType n)
        {
            _insert(_size(),n);
            // if(_finish == _endofstorage)
            // {
            //     size_t newcapacity = _capacity() > 0 ? _capacity()*2 : 3;
            //     _expand(newcapacity);
            // }
            // *_finish = n;
            // _finish++;
        }

        void _pop_back()
        {
            assert(_finish > _first);
            --_finish;
        }

        void _insert(size_t pos,DataType n)
        {
            assert(pos >= 0 && pos <= _size());
            size_t size = _size();
            if(_finish == _endofstorage)
            {
                size_t newcapacity = _capacity() > 0 ? _capacity()*2 : 3;
                _expand(newcapacity);
            }
            for(int i = size;i > pos;i--)
            {
                _first[i] = _first[i - 1];
            }
            _first[pos] = n;
            ++_finish;
            
        }

        void _erase(size_t pos)
        {
            assert(pos >= 0 && pos <= _size());
            size_t size = _size();
            for(int i = pos;i < size;i++)
            {
                _first[i] = _first[i+1];
            }
            --_finish;
        }

        size_t _find(DataType n)
        {
            size_t size = _size();
            for(int i = 0;i < size;i++)
            {
                if(_first[i] == n)
                    return i;
            }
        }
    private:
        void _expand(size_t n)
        {
            if(n > _capacity())
            {
                size_t size = _size();
                DataType* tmp = new DataType[n];
                memcpy(tmp,_first,size*sizeof(DataType));

                delete[] _first;
                _first = tmp;
                _finish = _first + size;
                _endofstorage = _first + n;
            }
        }
    protected:
        DataType* _first;   //指向顺序表的第一个位置
        DataType* _finish;  //指向顺序表中最后一个数据的下一个位置
        DataType* _endofstorage;    //指向表的容量的最大位置的下一个位置
};

测试的话读者可以自行补充。