c++之vector模拟实现与迭代器失效问题

vector模拟实现代码：

#pragma once
#include<assert.h>
#include<iostream>
#include<algorithm>


using namespace std;


namespace my_vector
{
    template<class T>
    class vector
    {
    public:
        typedef T* iterator;
        typedef const T* const_iterator;


         const_iterator begin()const
        {
            return _start;
        }
        const_iterator end()const
        {
            return _finish;
        }

        iterator begin()
        {
            return _start;
        }

        iterator end()
        {
            return _finish;
        }

        vector()
            :_start(nullptr)
            ,_finish(nullptr)
            ,_end_of_storage(nullptr)
        {
        }
        vector(size_t n, const T& val = T())
            : _start(nullptr)
            , _finish(nullptr)
            , _end_of_storage(nullptr)
        {
            int i = 0;
            for (i = 0; i < n; i++)
            {
                push_back(val);
            }
        }
        template<class InputIterator>
        vector(InputIterator* first, InputIterator* last)
            : _start(nullptr)
            , _finish(nullptr)
            , _end_of_storage(nullptr)
        {
            while (first != last)
            {
                push_back(*first);
                ++first;
            }
        }

        vector(const vector<T>& v)
            :_start(nullptr)
            ,_finish(nullptr)
            ,_end_of_storage(nullptr)
        {
            vector<T>tmp(v.begin(),v.end());
            swap(tmp);
        }

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

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

        size_t capacity()const
        {
            return _end_of_storage - _start;
        }
        void reserve(size_t n)
        {
            if (n > capacity())
            {
                size_t len = size();
                iterator tmp = new T[n];
                memcpy(tmp, _start,sizeof(T)*size());
                delete[]_start;
                _start = tmp;

                _finish = _start + len;
                _end_of_storage = n+_start;
            }
        }


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

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

        vector<T>& operator=(const vector<T>& v)
        {
            vector<T>tmp(v.begin(), v.end());
            swap(tmp);
            return *this;
        }

        void push_back(const T& x)
        {
            if (_finish == _end_of_storage)
            {
                reserve(capacity() == 0 ? 4 : 2 * capacity());
            }
            *_finish = x;
            ++_finish;
        }

        void pop_back()
        {
            assert(_finish > _start);
            --_finish;
        }

        iterator insert(iterator pos, const T& x)
        {
            assert(pos >= _start);
            assert(pos<=_finish);
            size_t len = pos - _start;
            if (_finish==_end_of_storage)
            {
                reserve(capacity() == 0 ? 4 : 2 * capacity());
            }
            iterator end = _finish - 1;
            pos = _start + len;//迭代器失效问题
            while (end >= pos)
            {
                *(end + 1) = *end;
                --end;
            }
            *pos = x;
            ++_finish;
            return _finish;
        }

        iterator erase(iterator pos)
        {
            assert(pos >= _start);
            assert(pos < _finish);
            iterator end = pos;
            while (end < _finish)
            {
                *end = *(end + 1);
                ++end;
            }
            _finish--;
            return pos;
        }


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

    void test_vector()
    {
        vector<int> v; 
        v.push_back(1);
        v.push_back(2);
        v.push_back(3);
        v.push_back(4);
        //v.push_back(5);
        auto p=find(v.begin(), v.end(), 3);
        v.insert(p, 30);
        //p = find(v.begin(), v.end(), 3);

        v.erase(v.begin());
        p = find(v.begin(), v.end(), 3);
        vector<int>v1 = v;
        vector<int>v2;
        v2 = v1;
        vector<int>v3(10,1);
        v.erase(p);
        for (auto e:v)
        {
            std::cout << e <<' ';
        }
        cout << endl;
        for (auto e : v1)
        {
            std::cout << e << ' ';
        }
        cout << endl;

        for (auto e : v3)
        {
            std::cout << e << ' ';
        }
        cout << endl;

    }

}

迭代器失效问题：

如在上图的insert函数中，如果插入了一个字符，导致vector扩容了，而在vector中，扩容函数如下：

实际上是新开了一块空间，将原空间释放，再将内容拷贝到_start里，那么就会导致传入的pos指针失效了，因为他原本指向的空间已经被释放了，这时候的POS就变成了野指针，这类问题在vector中我们称之为迭代器失效问题。

因此在insert函数中，我们设置了len变量来记录POS的位置，并且在扩容后进行更新。

这只是迭代器失效的一种普通的情况，在实际的vector中，迭代器失效的情况可能偶有发生，主要还是用户对vector指针进行了不当的操作。