关于vector的模拟实现

---

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

            const_iterator cbegin()
            {
                return _start;
        }

            const_iterator cend() const
            {
                return _finish;
        }



            // construct and destroy
            //这里不写，内置类型会自动初始化
            vector()
            {}

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

            template<class InputIterator>

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

            vector(const vector<T>& v)
            {
                reserve(v.capacity());
                for (auto& e:v)
                {
                    push_back(e);
                }
            }

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

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

            // capacity

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

            size_t capacity() const
            {
                return _end_of_storage - _start;
            }

            void reserve(size_t n)
            {
                //扩容前的检查
                if (n > capacity())
                {
                    T* tmp = new T[n];
                    size_t sz = size();
                    //扩容的同时检查旧空间是否有值
                    if (_start)
                    {
                        //如果有只值就拷贝过去（这里注意要深拷贝）
                        for (size_t i = 0; i < size(); i++)
                        {
                            tmp[i] = _start[i];
                        }
                        //删除旧空间同时注意是数组
                        delete[] _start;
                    }
                    //让类指向新空间，完成扩容
                    
                    //可以注意到这里sz是之前创建的，为的是保留让_finish能够正常找到它新在空间的位置
                    _start = tmp;
                    _finish = _start + sz;
                    _end_of_storage = _start + n;
                }
                
            }

            //resize经常要注意的是它的三种情况
            //1.n<=size()   将_finish修改即可
            //2.n>size() || n<capacity()    不需要扩容，插入即可
            //3.n>capacity()  需要扩容，也需要插入   
            //由于构建reserve()时检查过n>capacity(),下面只需要将1和2、3分成两种情况即可
            void resize(size_t n, const T& value = T())
            {
                if (n < size())
                {
                    _finish = _start + n;
                }
                else
                {
                    reserve(n);
                    //向[_finish,_start+n)内插入值
                    while (_finish < _start + n)
                    {
                        *_finish = value;
                        ++_finish;
                    }
                }
            }



            ///access///

            T& operator[](size_t pos)
            {
                //注意检查越界
                assert(pos < size());
                return _start[pos];

            }

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



            ///modify/

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

            void pop_back()
            {
                erase(_finish);
            }

            void swap(vector<T>& v)
            {
                _start = v._start;
                _finish = v._finish;
                _end_of_storage = v._end_of_storage;
            }

            
            void insert(iterator pos, const T& x)
            {
                //注意越界
                assert(pos >= _start);
                assert(pos <= _finish);
                //检查容量
                if (_finish == _end_of_storage)
                {
                    //记录迭代器扩容前相对位置
                    size_t len = pos - _start;
                    reserve(capacity() == 0 ? 4 : 2 * capacity());
                    pos = _start + len;
                }
                iterator end = _finish - 1;
                while (end >= pos)
                {
                    *(end + 1) = *end;
                    --end;
                }
                *pos = x;
                _finish++;
            }

            iterator erase(iterator pos)
            {
                //检查越界
                assert(pos >= _start);
                assert(pos < _finish);
                iterator it = pos + 1;
                while (it < _finish)
                {
                    *(it - 1) = *it;
                    it++;
                }
                _finish--;

                //为防止删除一个数据后，迭代器失效
                return pos;
            }

    private:

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

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

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

    };

}