（关于vector）迭代器失效问题-优快云博客

本文链接：https://blog.youkuaiyun.com/Mjdkd/article/details/127100283

本文通过三个示例展示了STL vector在使用erase操作时的正常与异常情况，包括正确删除偶数元素及导致崩溃或结果错误的场景。同时，介绍了自定义的myx_vector类实现，包括其成员函数如begin(), end(), reserve(), push_back(), pop_back(), insert()和erase()等。讨论了在实现自定义容器时需要注意的迭代器更新和内存管理问题。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

先放三个实例

做区别

//erase正常
   void test_vector1()
   {
       //正常运行的情况 -> 运气好
       vector<int> v;
       v.push_back(1);
       v.push_back(2);
       v.push_back(3);
       v.push_back(4);
       v.push_back(5);

//要求删除所有的偶数

       auto it = v.begin();
       while (it != v.end())
       {
           if (*it % 2 == 0)
           {
               it = v.erase(it);
           }
           else
           {
               ++it;
           }
       }

       for (auto e : v)
       {
           cout << e << " ";
       }
       cout << endl;
   }

   //erase不正常
   void test_vector2()
   {
       //不正常运行的情况 -> 崩溃（结尾是偶数）
       vector<int> v;
       v.push_back(1);
       v.push_back(2);
       v.push_back(3);
       v.push_back(4);
       //v.push_back(5);

//要求删除所有的偶数

       auto it = v.begin();
       while (it != v.end())
       {
           if (*it % 2 == 0)
           {
               it = v.erase(it);
           }
           else
           {
               ++it;
           }
       }

       for (auto e : v)
       {
           cout << e << " ";
       }
       cout << endl;
   }

   //erase不正常
   void test_vector3()
   {
       //不正常运行的情况 -> 错位，结果不对（出现连续偶数）
       vector<int> v;
       v.push_back(1);
       v.push_back(2);
       v.push_back(4);
       v.push_back(3);
       v.push_back(4);
       v.push_back(5);

//要求删除所有的偶数

       auto it = v.begin();
       while (it != v.end())
       {
           if (*it % 2 == 0)
           {
               it = v.erase(it);
           }
           else
           {
               ++it;
           }
       }

       for (auto e : v)
       {
           cout << e << " ";
       }
       cout << endl;
   }

这与我们所做的模拟vector有关

#include <assert.h>

namespace myx_vector
{
   template <class T>
   class vector
   {
   public:
       typedef T* iterator;
       typedef const T* const_iterator;
       //可以用原生指针来做迭代器
       //只要是连续的空间都可以用原生指针

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

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

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

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

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

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

       void reserve(size_t n)
       {
           if (n > capacity())
           {
               size_t sz = size();
               T* tmp = new T[n];
               if (_start)
               {
                   memcpy(tmp, _start, sizeof(T) * sz);
                   delete[] _start;
               }

               _start = tmp;
               _finish = _start + sz;
               _end_of_storage = _start + n;
           }
       }

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

           //iterator end = _finish - 1;
           //insert(end, x);
       }

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

       //插入
       void insert(iterator pos, const T& x)
       {
           //判断
           assert(pos >= _start);
           assert(pos <= _finish);

           //扩容问题 -》小心扩容后原来空间释放已经被tmp顶替
           // 这时pos失效，成为野指针
           if (_finish == _end_of_storage)
           {
               //解决方法：记录距离
               size_t len = pos - _start;
               reserve(capacity() == 0 ? 4 : capacity() * 2);
               pos = _start + len;
           }

           //挪动数据
           iterator end = _finish - 1;
           while (end >= pos)
           {
               *(end + 1) = *end;
               --end;
           }
           *pos = x;
           ++_finish;
       }

       // 删除
       //   stl 规定erase返回删除位置下一个位置迭代器
       iterator erase(iterator pos)
       {
           //判断
           assert(pos >= _start);
           assert(pos < _finish);

           iterator begin = pos + 1;
           while (begin < _finish)
           {
               *(begin - 1) = *begin;
               ++begin;
           }

--_finish;

           ////缩容问题
           //if (size() < capacity() / 2)
           //{
           //   //缩容意义 -> 以时间换空间
           // //开辟一个新空间，再复制过去，销毁原来的
           //   //有缩容效率会低
           //   //迭代器也有可能会失效
           //   //所以一般不使用这种方案
           //}

return pos;
}

   private:
       iterator _start;
       iterator _finish; //最后一个数据的下一个位置
       iterator _end_of_storage;//最大限量的下一个位置
   };

   void Func(const vector<int>& v)
   {
       vector<int>::const_iterator it = v.begin();//这里是const对象
       while (it != v.end())
       {
           //*it = 10; //只能读不能写
           cout << *it << " ";
           ++it;
       }
       cout << endl;

       //范围for 傻瓜式的替换， -> const对象也可以直接调用const迭代器
       for (auto e : v)
       {
           cout << e << " ";
       }
       cout << endl;
   }
}