迭代器失效（1）-小心使用STL容器的erase()

最新推荐文章于 2023-12-26 16:35:04 发布
最新推荐文章于 2023-12-26 16:35:04 发布
阅读量836 收藏
点赞数
分类专栏： QT

 

删除指定元素：

for (auto it = vec.begin(); it != vec.end(); )
 {
  if (*it ==3)
  {
   it = vec.erase(it);
  }
  else
  {
   it++;
  }
 }

 for (int i=0; i<vec.size(); i++)
 {
  if (vec[i] == 3)
  {
   std::vector<int>::iterator it = vec.begin()+i;

   vec.erase(it);

  }
 }

 

 

 

对于以下代码:

[cpp] view plain copy print ?
  1.    my_container.erase(iter);  
　　    my_container.erase(iter);

                其中my_container是STL的某种容器，iter是指向这个容器中某个元素的迭代器。如果不是在for,while循环中，

        这种方式删除元素没有问题，如果是在for,while中对m_container迭代，删除其中符合条件的所有元素，就可能出现问题。

         如果是在for,while中对m_container迭代，删除其中符合条件的所有元素，就可能出现问题。


        问题是：

                在迭代容器的时候删除元素，可能导致迭代器失效(invalidation of iterators)，产生未定义行为

         (undefined behavior)；

                例如，对某个迭代器解引用所获得的值并不是执行erase()前这个迭代器指向的值，还有可能对未指向任何

         元素的迭代器的解引用赋值而引发程序crash。

         类似的问题代码像这样：

[cpp] view plain copy print ?
  1. std::vector<int>  my_container; 
  2. for (int i = 0; i < 100; ++i) { 
  3.      my_container.push_back(i); 
  4. bsp;   } 
  5.  
  6. std::vector<int>::iterator it = my_container.begin(); 
  7. for (it != my_container.end(); it++) { 
  8.     if (*it % 2 == 1) { 
  9.          my_container.erase(it); 
  10.      } 
  11. }  
　　std::vector<int>  my_container;
　　for (int i = 0; i < 100; ++i) {
　　     my_container.push_back(i);
    }

　　std::vector<int>::iterator it = my_container.begin();
　　for (it != my_container.end(); it++) {
    	if (*it % 2 == 1) {
　　         my_container.erase(it);
　　     }
　　}
                my_container.erase(it)之后，it及其后面的迭代器已经失效，不应该再使用这些迭代器。再执行it++，其行为是未定义的。

       其他容器也会遇到迭代器失效的问题：

                对于vector 被删除元素的迭代器以及指向后面元素的迭代器全部失效。　　

                对于deque  在首部或尾部删除元素则只会使指向被删除元素的迭代器失效，任何其他位置的插入和删除操作将使指向该容器元素的

          所有迭代器失效。　　

                对于list 仅有指向被删除元素的迭代器失效。　　　　

                对于(mulit)map ，(multi)set 仅有指向被删除元素的迭代器失效。


              所以Golden Rule是：尽量不要使用容器的插入删除操作之前的迭代器。

              为什么不同容器迭代器失效情况有差别？这与实现各容器的数据结构有关。　　

              如何在迭代容器时删除其中的元素？各容器通用的做法如下：

[cpp] view plain copy print ?
  1.          std::vector<int>::iterator it = my_container.begin(); 
  2.          for (it != my_container.end();/**blank*/ ) { 
  3.               if (*it % 2 == 1) { 
  4.                    my_container.erase(it++); 
  5.               } 
  6.               else{ 
  7.                    it++; 
  8.               } 
  9.          }  
　　          std::vector<int>::iterator it = my_container.begin();
　　          for (it != my_container.end();/**blank*/ ) {
    	          if (*it % 2 == 1) {
　　                    my_container.erase(it++);
　　               }
　　               else{
　　                    it++;
　　               }
　　          }

                     my_container.erase(it++) 巧妙得在执行erase()之前，it 先自增，指向被删除元素后面的元素，而给erase()传递的是未自增的it迭代器，

            以定位要删除的元素。如果元素的值为奇数，则删除此元素，it指向下一个元素，如果元素的值为偶数，则检查下一个元素的值。整个迭代过程中

            迭代器就不会失效了。

                    上段代码中两个不同分支出现了i++操作，下面的代码示例显示了如何防止遗忘其中任何一个分支的i++操作。         

[cpp] view plain copy print ?
  1.             MyContainer::iterator it = myContainer.begin(); 
  2.             While(it != myContainer.end()){ 
  3. 　　             MyContainer::iterator curIt = it; 
  4. 　　             if (*curIt == matchingValue)    { 
  5. 　　                     myContainer.erase(curIt); 
  6. 　　             } 
  7.             }  
            MyContainer::iterator it = myContainer.begin();
            While(it != myContainer.end()){
　　             MyContainer::iterator curIt = it;
　　             if (*curIt == matchingValue)    {
　　                     myContainer.erase(curIt);
　　             }
            }
                    对于vector ,deque, list, 另一种可行的方式是:
                          
[cpp] view plain copy print ?
  1. std::vector<int>::iterator it = my_container.begin(); 
  2. for (it != my_container.end();/**blank*/ ) { 
  3.    if (*it % 2 == 1) { 
  4.          it = my_container.erase(it); 
  5.      } 
  6.      else{ 
  7.           it++; 
  8.      } 
  9. }  
　　         std::vector<int>::iterator it = my_container.begin();
　　         for (it != my_container.end();/**blank*/ ) {
    	         if (*it % 2 == 1) {
　　                  it = my_container.erase(it);
　　              }
　　              else{
　　                   it++;
　　              }
　　         }
                   上面代码可行的原因是vector::erase() 返回一个新的迭代器，指向被删除元素的后面的元素。可以继续使用新的迭代器。

                   而出于某种未知的原因(multi)map::erase(), (multi)set::erase()没有返回这样的迭代器。(从C++11开始也支持返回迭代器了).

                  

                   但是对于vector，诸如在0到99个数中删除所有奇数的问题，可以使用STL的remove(),remove_if()优化性能。代码如下：   

[cpp] view plain copy print ?
  1. bool isOdd(int value) 
  2. { 
  3.      return (value % 2) == 1; 
  4. } 
  5.  
  6. my_container.erase( std::remove_if(m_container.begin(), m_container.end(), isOdd), m_container.end()); 
　　        bool isOdd(int value)
　　        {
　　             return (value % 2) == 1;
　　        }

　　        my_container.erase( std::remove_if(m_container.begin(), m_container.end(), isOdd), m_container.end());
                   让我们再看看不使用remove_if()的版本：                
[cpp] view plain copy print ?
  1. for (it != my_container.end();/**blank*/ ) { 
  2.    if (*it % 2 == 1) { 
  3.          it = my_container.erase(it); 
  4.      } 
  5.      else{ 
  6.           it++; 
  7.      } 
  8. }  
　　        for (it != my_container.end();/**blank*/ ) {
    	        if (*it % 2 == 1) {
　　                 it = my_container.erase(it);
　　             }
　　             else{
　　                  it++;
　　             }
　　         }

                   如果你阅读过erase()源码或了解它是如何工作的，性能问题就显而易见：erase()删除一个元素的操作是被删除元素后面的所有元素依次

           向前移动一个元素的位置，然后删除最后一个元素,时间复杂度为O(n^2)。

                   remove(),remove_if()的时间复杂度为O(n),删除元素的操作如下所示：

                 

[cpp] view plain copy print ?
  1. template<class ForwardIt,class UnaryPredicate> 
  2. ForwardIt remove_if(ForwardIt first, ForwardIt last, UnaryPredicate p) 
  3. { 
  4.       ForwardIt result = first; 
  5.       for (; first != last; ++first) { 
  6.            if (!p(*first)) { 
  7.                 *result++ = *first; 
  8.            } 
  9.       } 
  10.       return result; 
  11. }  
　　          template<class ForwardIt, class UnaryPredicate>
　　          ForwardIt remove_if(ForwardIt first, ForwardIt last, UnaryPredicate p)
　　          {
　　                ForwardIt result = first;
　　                for (; first != last; ++first) {
　　                     if (!p(*first)) {
　　                          *result++ = *first;
　　                     }
　　                }
　　                return result;
　　           }
                     从前向后遍历容器所有元素，将待保留的元素向前移动，占据待删除的元素的位置，remove_if()返回新的元素范围(begin,end)中的end，

             记为new_end_of_range ，再调用erase()删除从new_end_of_range到my_container.end()之间的所有元素。

                     实际上，remove_if() 没有删除容器中的任何元素，它没有改变my_container.end(), 调用remove_if()后容器元素个数不会改变!!删除元素的工作

              交给了erase().

                    


                       Scott Meyers在他的”Effective STL”中关于此问题的讨论中也使用了remove_if()，由此看来，他的确是提出了一些让STL effective的建议。


              深入学习STL迭代器失效问题：

                        在google中搜索 stl iterator invalidation rules 可以获得很多有关STL迭代器失效的有关内容。

           

              References:

              1. STL remove_if()       http://en.cppreference.com/w/cpp/algorithm/remove

              2.More C++ Idioms/Erase-Remove 　　http://en.wikibooks.org/wiki/More_C%2B%2B_Idioms/Erase-Remove

              3.Effective STL, Item 32 - Scott Meyers

              4.Cpp Invalid Iterators [对各种迭代器失效的情况进行了讲解分类]

                   http://www.angelikalanger.com/Conferences/Slides/CppInvalidIterators-DevConnections-2002.pdf              

              5.以下是stackoverflow上关于在迭代时删除容器中元素的讨论:

                 http://stackoverflow.com/questions/1604588/iterate-vector-remove-certain-items-as-i-go

                 http://stackoverflow.com/questions/3747691/stdvector-iterator-invalidation?rq=1

                 http://stackoverflow.com/questions/2874441/deleting-elements-from-stl-set-while-iterating?rq=1

                  http://stackoverflow.com/questions/1038708/erase-remove-contents-from-the-map-or-any-other-stl

                        -container-while-iterating/1038761#1038761

                  http://stackoverflow.com/questions/799314/difference-between-erase-and-remove?rq=1

杜xx
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
字符串去重——迭代器和erase的使用
营养不良的红
09-01 931
string的erase方法可以回收内存，与vector不同。 1、问题描述：输入两个字符串，将第一个字符串中与第二个字符串相同的部分消掉，直到第一个字符串中没有与第二个字符串相同的部分。优先消除靠近第一个字符串串首的相同部分。假设两个字符串不会完全相同。 输入：两个字符串，以空格隔开，最大长度为256字符 输出：余下未消除的字符串 样例输入：abc121233 123  样例输出：ab
关于STL的erase()陷阱-迭代器失效问题的总结
08-31
然而，使用`erase()`时需要特别注意的一个问题是迭代器失效，即在删除元素后，与该元素相关的迭代器将不再有效。本文将深入探讨这个问题，并通过实例分析在不同类型的STL容器中如何安全地使用`erase()`。 首先，让...
STL的erase()陷阱-迭代器失效总结
jinchengzhou的专栏
01-13 2063
阅读目录(Content) 1.list,set,map容器 1.1 正确写法1 1.2 正确写法2 1.3 错误写法1 1.4 错误写法2 1.5 分析 2. vector,deque容器 2.1 正确写法 2.2 注意 3.迭代器失效的情况 3.1 vector 3.2 deque 3.3 list 3.4 slist 3.5 stack 3.6 queue 3.7 priority_queue 3.8 set 3.9 multi
erase 函数使迭代器失效
青海蓝田的博客
08-17 719
顺序容器的删除操作： 这些操作会改变容器的大小，所以不适用于 array 顺序容器的类型： vector 可变大小的数组。支持快速随机访问，在尾部之外的位置插入或删除元素可能很慢。 deque 双端队列。支持快速随机访问，在头尾位置插入或删除的速度很快。 list 双向链表。只支持双向顺序访问。在 list 中任何位置进行插入或删除操作的速度都很快。 ...
STL迭代器异常 map,set的erase()和insert()操作
Evildoer_llc的博客
10-08 695
我们都知道在STL中有迭代器，但是erase()和insert()操作会使迭代器异常 erase()会删除迭代器 例如： set<int>st; set<int>::iterator it = st.begin() for(it;it!=st.end();it++) { erase(*it); } 我们通常会这样来删除set中的元素，但是这样删除的话，会把...
浅谈c++ stl迭代器失效的问题
08-31
本文将深入探讨STL迭代器失效的问题，特别是在执行插入（insert）和删除（erase）操作时。 首先，让我们来看一下在删除元素时迭代器失效的情况。迭代器失效是指在执行某些操作后，原本有效的迭代器变得不可用，通常...
c++迭代器失效的情况汇总
08-19
C++迭代器失效是指在使用容器时，迭代器失去了指向正确元素的能力，而导致程序出错或崩溃。这种情况在C++编程中非常常见，尤其是在使用STL容器时。了解迭代器失效的情况可以帮助我们更好地编写C++程序，避免一些常见...
容器迭代器erase
xuleisdjn的专栏
04-07 1764
AssociContainer <int> c;　　//关联容器：mapset for(auto it=c.begin();it!=c.end();) { 　　if(badValue(*it)) 　　　　c.erase(it++);　　//关联容器set/map c++11之前版本 erase返回值为void 　　else 　　　　++it; } 说明：c.erase(it++) 会把it的旧值传给erase，但在erase开始执行之前it会自增，正好符合我们的期望。关联容器这样写没有任何..
STL：在循环中使用erase报错的情况
冷锋的博客
02-13 575
之前想写个程序，利用iterator遍历list，然后用if语句删除特定值 像下面这样： for(list<int>::iterator iter=lst.begin();iter!=lst.end(); iter++) { if(*iter==20) { lst.erase(iter); } cout<<*iter<<endl; }...
每日 C++ - STL 迭代器 erase 使用陷阱
whose book 的博客
09-27 497
STL 迭代器 erase 使用陷阱 我们通常在操作容器删除某元素操作时，会遇到一些迭代器失效的问题，我们就清空容器操作来作说明 vector 容器清空 vector 清空的正确示例 vector<int> vec{1, 2, 3}; vector<int>::iterator iter = vec.begin(); while (iter != vec.end()) { vec.erase(iter); } 或者 vector<int> vec{1, 2, 3};
vector之erase和迭代器
weixin_34364135的博客
04-24 259
C++开发中使用vector时非常方便的，但是也是需要非常小心的，最近在使用容器删除某个元素的时候，测试结果出现了异常 /* vector erase test*/ int testVector() { vector<int> intVec; /* init vector */ for(int i = 0; i < 10; ++i) { ...
STL 中使用erase操作删除迭代器的问题
12-05 458
迭代器 iterator earse 注意事项
Remove Element——leetcode 迭代器erase备注说明
xiangjiaoyun的博客
10-16 200
注意迭代器删除元素的使用
当C++容器的迭代器iterator遇到删除函数erase时
hexunhua617的博客
08-08 5681
      C++中添加了各种各样的STL容器，不仅数量众多，而且功能强大，如果能够正常使用，可以使我们省去诸多时间。迭代器（iterator）是一种对象，它能够用来遍历标准模板库容器中的部分或全部元素，每个迭代器对象代表容器中的确定的地址，简单点就是每个“节点”对象的“指针”。        不过，虽然C++的STL容器功能强大，但是由于C++语言的自由性（简直自由的令人发指），也会让我们在使...
vector的erase()方法遍历删除元素迭代器失效问题、及删除最后一个元素迭代器失效问题）
qq_19272431的博客
12-26 2731
vector 删除指定元素
C++ 迭代器 删除（erase）插入（insert）之后失效
软件工程小施同学 的专栏
10-22 1130
初学者的我在学习迭代器的时候（今天这里主要说的是vector的迭代器）碰到了一些问题，纠结了好些时候，总算弄明白了一点。 迭代器会在删除插入等操作后失效，即在其删除插入位置后的迭代器会失效，那所谓的失效是什么意思？ 失效一般是指迭代器指向了和你预期不一样的位置了，但这个时候，你可以通过自增自减使它指向正确位置，但是，注意，有些时候，你是不能这样做的，迭代器会完全失效，必须重新初始化。 迭代器像指针但又不是指针，指针是指向某个地之后，除非你改变它的指向，要不然它是不会因为其他操作使它的指向发生变化的，迭
STL 迭代器 erase 的一个错误用法
xiaocainiao320的专栏
10-31 464
今天代码出现了一个异常
【STL的erase()陷阱-迭代器失效总结】
weixin_42282363的博客
03-09 390
STL容器erase使用规范与陷阱
stl erase迭代器后，迭代器会自动++吗
最新发布
03-13
在STL中，当使用erase函数删除一个元素后，被删除元素后面的元素会向前移动填补空缺，而被删除的元素的迭代器会失效。此时，如果你继续使用失效的迭代器进行自增操作，会导致未定义的行为。 因此，当你使用erase函数删除元素后，建议更新迭代器，使其指向正确的位置。可以通过将erase函数的返回值赋给迭代器来实现，这样迭代器会指向被删除元素的下一个位置。 下面是一个示例代码： ``` std::vector<int> vec = {1, 2, 3, 4, 5}; auto it = vec.begin(); it = vec.erase(it); // 删除第一个元素，并将it更新为指向第二个元素 ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值