vector模拟实现

#include<assert.h>
#include<iostream>

namespace bit

{

    template<class T>

    class vector

    {

    public:

        // Vector的迭代器是一个原生指针

        typedef T* iterator；

            typedef const T* const_iterator；

            iterator begin()
        {
            return _start;
        }

        iterator end()
        {
            return _finish + 1;
        }

        const_iterator cbegin()
        {
            return _start;
        }

        const_iterator cend() const
        {
            return _finish + 1;
        }



        // construct and destroy

        vector()
            :_start(nullptr)
            , _finish(nullptr)
            , _endOfStorage(nullptr)
        {}

        vector(int n, const T& value = T())
            :_start(nullptr)
            , _finish(nullptr)
            , _endOfStorage(nullptr)
        {
            reserve(n);
            for (int i = 0; i < n; i++)
            {
                push_back(value);
            }
        }

        template<class InputIterator>

        vector(InputIterator first, InputIterator last)
        {
            while (fist != last)
            {
                push_back(*fist);
                fist++;
            }
        }

        vector(const vector<T>& v)
            :_start(nullptr)
            , _finish(nullptr)
            , _endOfStorage(nullptr)
        {
            iterator it = begin();
            const_iterator vit = v.begin;
            while (vit < v.end)
            {
                *it++ = *vit++;
            }
            _finish = it;
        }

        vector<T>& operator= (vector<T> v)
        {
            swap(v);
            return *this;
        }

        ~vector()
        {
            if (_start)
            {
                delete[]_start;
                _start = _finish = _endOfStorage = nullptr;
            }
        }

        // capacity

        size_t size() const
        {
            return _finish - _start;
        }

        size_t capacity() const
        {
            return _endOfStorage = _start;
        }

        void reserve(size_t n)
        {
            if (n > size())
            {
                int oldsize = size();
                tmp = new T[n];
                if (_start)
                {
                    for (int i = 0; i < n; i++)
                    {
                        tmp[i] = _start[i];
                    }
                    delete[]_start;
                }
                _start = tmp;
                _finish = tmp + oldsize;
                _endOfStorage = _start + n;
            }
        }

        void resize(size_t n, const T& value = T())
        {
            if (n <= size)
            {
                _finish = _start + n;
            }
            else
            {
                if (n > capacity())
                {
                    reserve(n);
                }
                iterator it = _finish;
                _finish = _start + n;
                while (it != _finish)
                {
                    *it = value;
                    ++it;
                }
            }
        }
    


            ///access///

        T& operator[](size_t pos)
        {
            assert(pos < size());
            return _start[pos];
        }

        const T& operator[](size_t pos)const
        {
            asser(pos < size());
            return _start[pos];
        }



            ///modify/

        void push_back(const T& x)
        {
            insert(_end, x);
        }

        void pop_back()
        {
            erase(_end - 1);
        }

        void swap(vector<T>& v)
        {
            std::swap(_start, v._start);
            std::swap(_finish, v._finish);
            std::swap(_endOfStorage, v._endOfStorage);
        }

        iterator insert(iterator pos, const T& x)
        {
            assert(pos <= _finish);
            if(_finish== _endOfStorage)
            {
                size_t capacity = (capacity == 0) ? 1 : capacity() * 2;
                reserve(capacity);
                pos = _start + _size();
            }
            iterate end = _finish-1;
            while(end>=pos)
            {
                *(end + 1) = *end;
                end--;
            }
            *pos = x;
            _finish++;
            return pos;
        }

        iterator erase(iterator pos)
        {
            // 挪动数据进行删除
            iterator begin = pos + 1;
            while (begin != _finish) {
                *(begin - 1) = *begin;
                ++begin;
            }

            --_finish;
            return pos;
        }

    private:

        iterator _start; // 指向数据块的开始

        iterator _finish; // 指向有效数据的尾

        iterator _endOfStorage; // 指向存储容量的尾

    };

}