deque迭代器失效的困惑？

最新推荐文章于 2024-08-15 13:00:07 发布
原创 最新推荐文章于 2024-08-15 13:00:07 发布 · 2.2k 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文深入探讨了C++ deque容器中迭代器失效的机制，澄清了误解，并提供了正确的解释和官方规则，帮助开发者更好地理解deque的内部工作原理。

在实现LRU算法的时候lru_list 开始用的是deque 但是因为害怕其在插入删除上的迭代器失效情况的诡异情况。遂用list代替之。

在数据量比较大的时候性能不是很好。性能优化分析的时候决定用deque替换回来。于是对deque迭代器失效的情况好好研究了一下：


c++ primer如此写道：

1.在deque容器首部或者尾部插入元素不会使得任何迭代器失效。 
2.在其首部或尾部删除元素则只会使指向被删除元素的迭代器失效。 
3.在deque容器的任何其他位置的插入和删除操作将使指向该容器元素的所有迭代器失效。


stackoverflow上对此的讨论：Confusion on iterators invalidation in deque



I'm bit confused regarding iterator invalidation in deque. (In the context of this question)

Following is the excerpts from -- The C++ Standard Library: A Tutorial and Reference, By Nicolai M. Josuttis

Any insertion or deletion of elements other than at the beginning or end invalidates all pointers, references, and iterators that refer to elements of the deque.

Following is the excerpts from SGI site:

The semantics of iterator invalidation for deque is as follows. Insert (including push_front and push_back) invalidates all iterators that refer to a deque. Erase in the middle of a deque invalidates all iterators that refer to the deque. Erase at the beginning or end of a deque (including pop_front and pop_back) invalidates an iterator only if it points to the erased element.

IMHO, deque is collection of blocks with first block growing in one direction and the last block in opposite direction.

  -   -  -  
  -   -  -
  |   -  -  ^
  |   -  -  |
  V   -  -  |
      -  -  -
      -  -  -

push_back, push_front should not have any impact on deque iterators ( I agree with Josuttis).

What is the correct explanation? what the standard say on this?

完美的答案：

IMHO, deque is collection of blocks with first block growing in one direction and the last block in opposite direction.

Your opinion is your prerogative, but it's wrong. :)

deque is such a container semantically, but in terms of implementation it's designed to be implemented by one or more blocks of memory. C++'s iterator invalidation rules come from implementation, so this is why. Arguably this is a small abstraction leak but, well, whatever.

The SGI STL documentation is not the proper documentation to read, because the SGI STL is not the C++ Standard Library. Unfortunately, Josuttis is one of those people who calls it "the STL", and this has led to your confusion.

Following is the excerpts from -- The C++ Standard Library: A Tutorial and Reference, By Nicolai M. Josuttis

Any insertion or deletion of elements other than at the beginning or end invalidates all pointers, references, and iterators that refer to elements of the deque.

Put simply, this passage from Josuttis is misleading in implying that the insertion or deletion of elements thatare at the beginning or end do not invalidate pointers, references or iterators … though it's worth noting that he never comes out and asserts this outright.

Here are the real, proper, official rules for std::deque:

C++03

  • Insertion: all iterators and references are invalidated, unless the inserted member is at an end (front or back) of the deque (in which case all iterators are invalidated, but references to elements are unaffected) [23.2.1.3/1]

  • Erasure: all iterators and references are invalidated, unless the erased members are at an end (front or back) of the deque (in which case only iterators and references to the erased members are invalidated) [23.2.1.3/4]

  • Resizing: as per insert/erase [23.2.1.2/1]

C++11

  • Insertion: all iterators and references are invalidated, unless the inserted member is at an end (front or back) of the deque (in which case all iterators are invalidated, but references to elements are unaffected) [23.3.3.4/1]

  • Erasure: erasing the last element invalidates only iterators and references to the erased elements and the past-the-end iterator; erasing the first element invalidates only iterators and references to the erased elements; erasing any other elements invalidates all iterators and references (including the past-the-end iterator) [23.3.3.4/4]

  • Resizing: as per insert/erase [23.3.3.4/1]

Further reading



智能客户AI服务平台的模型评估架构设计实战
AI天才研究院
07-31 1036
想象你去餐厅吃饭，服务员（智能客服）给你推荐菜品：你说"想吃辣的"，他推荐了甜粥；你问"能开发票吗"，他回答"今天天气不错"——这样的服务体验显然会让你抓狂。在智能客户AI服务平台中，类似的"服务失误"往往源于AI模型效果不佳。模型评估架构的核心目的，就是避免这类"服务事故"：通过科学的方法持续判断模型"是否好用"“哪里不好用”“如何改进”，最终让AI客服既能"听懂话"（意图识别准确）、又能"说对话"（回答质量高）、还能"持续进步"（适应变化）。
STL“源码“剖析-重点知识总结
qq_33287871的博客
07-28 274
STL是C++重要的组件之一，大学时看过《STL源码剖析》这本书，这几天复习了一下，总结出以下LZ认为比较重要的知识点，内容有点略多 :) 1、STL概述 STL提供六大组件，彼此可以组合套用： 1.容器（Containers）：各种数据结构，如：vector、list、deque、set、map。用来存放数据。从实现的角度来看，STL容器是一种class template。 2.算法（algorithms）：各种常用算法，如：sort、search、copy、erase。从实现的角度来看，STL算法是一
STL 4： STL之容器：选择时机，删除元素，迭代器失效
花落孤独
03-26 5669
        一. 种类： 标准STL序列容器：vector、string、deque和list。 标准STL关联容器：set、multiset、map和multimap。 非标准序列容器slist和rope。slist是一个单向链表，rope本质上是一个重型字符串 非标准关联容器hash_set、hash_multiset、hash_map和ha
deque 迭代器失效的问题详解
monkey_D_feilong的博客
07-04 5869
今天在看STL源码的时候，无意写了如下的代码，发现程序崩溃了： deque::iterator iter=d.begin(); d.insert(iter,5); d.insert(iter,6); //崩溃，迭代器失效了 之前一直没有留意这个问题，后来结合源码和查找资料，得到如下的结论： 插入操作： 1、在队前或队后插入元素时（push_back(),pus
STL中，deque插入或删除元素时，迭代器是否失效的问题
ZiZhanOld的博客
05-23 1323
在vs2013上编程测试后，总结如下： deque d1; 在deque中增加任何元素都将使deque的所有迭代器失效。 在deque的中间删除元素将使所有的迭代器失效。 在deque的头或尾（d1.begin(),d1.end()）删除元素时，只有指向该元素的迭代器失效。
迭代器失效小结
Make Progress Everyday!
07-26 1281
      迭代器（iterator）是一个可以对其执行类似指针的操作（如：解除引用（operator*()）和递增（operator++()））的对象，我们可以将它理解成为一个指针。但它又不是我们所谓普通的指针，我们可以称之为广义指针，你可以通过sizeof（vector::iterator）来查看，所占内存并不是4个字节。    首先对于vector而言，添加和删除操作可能使容器的
deque及迭代器失效问题
ww32cc的博客
09-05 5120
deque由一段一段的定量连续空间构成，采用一个表（map）来记录每个连续空间的首址，map是一小块连续的空间，目的是便于迭代器的寻址（map+1即可跳转到下一个连续空间的首址）。map中的每一个元素（node）都是指针，指向另一端（较大的）连续线性空间，称为缓冲区，缓冲区才是deque的储存空间主体。具体机制如下所示： 其中，对迭代器it的解引用得到的是cur位置处对应的元素。 de
迭代器是什么数据类型，
03-23
// 可能导致迭代器失效（内存重分配） // *it; // 未定义行为！ ``` 2. **类型获取方式** - 直接使用 `auto` 声明（推荐）： ```cpp auto it = container.begin(); ``` - 显式指定类型（适用于需要明确...
不够详细，迭代器、适配器、空间配置器这些都没讲
02-26
还要提到迭代器失效的问题，这是实际编程中常见的问题，用户可能会遇到。 2. **适配器**：除了容器适配器（如stack、queue），还有迭代器适配器和函数适配器。比如反向迭代器、插入迭代器，以及C++11中的bind和...
Rust基础拾遗--结构体、枚举与模式、迭代器、集合
yaoming168的专栏
02-10 1286
通过`Rust程序设计-第二版`笔记的形式对Rust相关`重点知识`进行汇总，读者通读此系列文章就可以轻松的把该语言基础捡起来。
迭代器失效
cat_little_cat的博客
11-05 263
迭代器是什么 迭代器类型类似于指针类型，也提供了对对象的间接访问。就迭代器而言，其对象便是容器中的元素或者string对象中的字符。使用迭代器可以访问某个元素，迭代器也能从一个元素移动到另一个元素。迭代器有有效和无效之分，这一点和指针差不多。有效的迭代器指向某个元素，或者指向容器中尾元素的下一位置。 我们可以把迭代器理解为指针 但它又不同于指针 。比如我们用sizeof来测它所占的内存，它并不占...
STL源码剖析---迭代器失效小结
tempsitegoogle
07-10 314
迭代器（iterator）是一个可以对其执行类似指针的操作（如：解除引用（operator*()）和递增（operator++()））的对象，我们可以将它理解成为一个指针。但它又不是我们所谓普通的指针，我们可以称之为广义指针，你可以通过sizeof（vector::iterator）来查看，所占内存并不是4个字节。 首先对于vector而言，添加和删除操作可能使容器的部分或者全部迭代器失...
C++ STL中deque容器，插入和删除元素时造成迭代器失效——指向发生错乱
m0_74835231的博客
08-15 357
C++ STL中deque容器，插入和删除元素时造成迭代器失效——指向发生错乱
容器删除元素后迭代器失效_STL 4： STL之容器：选择时机，删除元素，迭代器失效...
weixin_36284848的博客
12-24 352
一. 种类：标准STL序列容器：vector、string、deque和list。标准STL关联容器：set、multiset、map和multimap。非标准序列容器slist和rope。slist是一个单向链表，rope本质上是一个重型字符串非标准关联容器hash_set、hash_multiset、hash_map和hash_multimap。几种标准非STL容器，包括数组、bitset、v...
STL vector,list,deque删除迭代器失效问题
u010563492的博客
08-23 572
收藏的Effective STL，翻开条款9，找到了erase容器中元素的原则。以前曾经看过，不过年深日久，早就忘得一干二净了。现在还是把要点总结一下，记在blog上，供以后参考。 1. 对于关联容器(如map, set, multimap,multiset)，删除当前的iterator，仅仅会使当前的iterator失效，只要在erase时，递增当前iterator即可。这是因为map之类
迭代器失效（二）
qq_61084129的博客
02-04 461
这两个不支持扩容，因此不需要考虑扩容的情况，底层实现是红黑树，在进行数据的插入删除时应该是会改变节点的指向，但并不会改变节点的地址，也就意味着不会发生和vector一样因插入删除改变元素的位置而导致的迭代器失效。在双端队列中，无论是扩容还是插入（头插尾插中间插）都会导致迭代器的失效，只有当删除头尾的时候不会导致中间位置的迭代器失效，删除中间的位置都会导致迭代器失效。在上篇文章中提到了关于在vector和list中的迭代器失效的情况，但是STL中的容器种类是非常多的，因此还需要再补充一些。
C++ STL学习之三：容器deque深入学习
daisyZH的专栏
02-21 613
转自：http://www.2cto.com/kf/201204/126761.html C++ STL容器deque和vector很类似，也是采用动态数组来管理元素。 使用deque之前需包含头文件： #include   它是定义在命名空间std内的一个class template： template class _Ax = allocator > class deq
C++ stl迭代器 （迭代器失效问题）
知识分享与学习笔记总结，欢迎指点
04-08 4607
C++剖析stl 迭代器是什么？：迭代器 和 指针;迭代器失效;详解`vector`迭代器失效
如何避免vector迭代器失效？
最新发布
08-20
<think>我们正在讨论如何避免vector在插入或删除操作时的迭代器失效问题。根据引用[1][2][3][4]，vector的迭代器失效主要发生在两种情况下： 1. 插入操作导致内存重新分配（增容）：所有迭代器失效。 2. 删除操作（特别是中间元素）：被删除元素之后的迭代器失效。 为了避免迭代器失效，我们可以采取以下策略： ### 1. **预分配空间（reserve）避免增容** - 在插入大量元素前，使用`reserve()`预先分配足够内存，避免插入过程中多次增容导致迭代器失效[^1]。 - 示例： ```cpp std::vector<int> vec; vec.reserve(100); // 预分配100个元素空间 auto it = vec.begin(); for (int i = 0; i < 100; ++i) { vec.push_back(i); // 在预分配空间内插入，不会增容，it保持有效 } // 注意：若插入数量超过100，增容仍会导致it失效 ``` ### 2. **插入操作后更新迭代器** - 插入操作后，原有迭代器可能失效（特别是触发增容时）。因此，插入后应避免使用旧的迭代器，而是使用返回的新迭代器（如`insert()`返回值）[^1][^3]。 - 示例： ```cpp std::vector<int> vec = {1, 3}; auto it = vec.begin() + 1; // 指向3 it = vec.insert(it, 2); // 在位置1插入2，返回指向新元素2的迭代器 // 此时it有效，指向新插入的2 ``` ### 3. **删除操作时使用`erase()`返回值更新迭代器** - `erase(iterator pos)`返回被删除元素的下一个有效迭代器[^3][^4]。直接使用返回值更新迭代器，避免失效。 - 示例（删除所有偶数）： ```cpp std::vector<int> vec = {1, 2, 3, 4}; auto it = vec.begin(); while (it != vec.end()) { if (*it % 2 == 0) { it = vec.erase(it); // it更新为下一个有效位置 } else { ++it; // 手动移动到下一个位置 } } ``` ### 4. **避免保存跨操作的迭代器** - 在插入或删除操作后，之前保存的迭代器（如`begin()`、`end()`）可能失效。建议在每次操作后重新获取迭代器[^1][^4]。 - 错误示例： ```cpp std::vector<int> vec = {1, 2, 3}; auto start = vec.begin(); vec.push_back(4); // 可能导致增容，start失效！ // 错误：使用已失效的start std::cout << *start << std::endl; // 未定义行为！ ``` ### 5. **使用索引替代迭代器** - 若需保留位置信息，改用整数索引（下标）访问元素。索引在插入/删除后需手动调整，但不会“失效”[^3]。 - 示例： ```cpp std::vector<int> vec = {10, 20, 30}; int index = 1; // 记录位置1（元素20） vec.erase(vec.begin() + index); // 删除位置1的元素 // 此时index仍表示位置1，但元素变为30 ``` ### 6. **利用算法库简化删除操作** - 使用`std::remove`或`std::remove_if`搭配`erase()`批量删除元素（“擦除-移除”惯用法），避免手动管理迭代器[^3]。 - 示例（删除所有偶数）： ```cpp std::vector<int> vec = {1, 2, 3, 4}; vec.erase(std::remove_if(vec.begin(), vec.end(), [](int x) { return x % 2 == 0; }), vec.end()); ``` ### 总结：关键原则 | **操作** | **风险** | **解决方案** | |----------------|--------------------------|----------------------------------| | 插入（尾部） | 增容导致所有迭代器失效 | 预分配空间（`reserve()`） | | 插入（任意位置）| 增容或元素移动导致失效 | 使用`insert()`返回值更新迭代器 | | 删除 | 后续元素迭代器失效 | 使用`erase()`返回值更新迭代器 | | 通用操作 | 跨操作迭代器失效 | 避免长期保存迭代器，改用索引 | > **注意**：`vector`的迭代器失效是底层连续内存结构的必然结果。遵循上述策略可规避风险，但若需频繁中间插入/删除，建议改用`list`或`deque`[^1][^2]。 §§相关问题§§ 1. vector的reserve()和resize()有什么区别？ 2. 如何安全地遍历vector并删除元素？ 3. list和vector在迭代器失效方面有何本质区别？ 4. C++中哪些容器不会因插入删除导致迭代器失效？</think>### 如何避免vector插入/删除操作时的迭代器失效 在C++中，`vector`的迭代器失效主要发生在两种场景： 1. **插入操作导致内存重新分配**：当插入元素超过当前容量时，所有迭代器失效[^1][^2] 2. **删除操作**：被删除位置及之后的所有迭代器失效[^3][^4] 以下是具体解决方案和最佳实践： #### 1. **预分配空间避免重新分配** ```cpp std::vector<int> vec; vec.reserve(100); // 预分配100个元素空间 auto it = vec.begin(); for(int i=0; i<50; ++i) { vec.push_back(i); // 在预分配空间内插入，it保持有效 } // 注意：若插入超过100个元素，仍会导致重新分配 ``` #### 2. **使用`insert()`返回值更新迭代器** ```cpp std::vector<int> vec = {1, 3}; auto it = vec.begin() + 1; // 指向3 // 插入后返回新元素位置的迭代器 it = vec.insert(it, 2); // vec变为{1,2,3}, it指向新插入的2 ``` #### 3. **使用`erase()`返回值更新迭代器** ```cpp std::vector<int> vec = {1,2,3,4}; auto it = vec.begin(); while(it != vec.end()) { if(*it % 2 == 0) { it = vec.erase(it); // 返回删除元素的下一个位置 } else { ++it; // 手动移动到下一位置 } } // vec最终为{1,3} ``` #### 4. **避免保存长期有效的迭代器** ```cpp std::vector<int> vec = {10,20,30}; auto start = vec.begin(); // 危险：可能失效 vec.push_back(40); // 可能导致增容 // 安全做法：需要时重新获取 auto safe_start = vec.begin(); ``` #### 5. **使用索引替代迭代器** ```cpp std::vector<int> vec = {5,10,15}; size_t index = 1; // 记录位置 vec.erase(vec.begin() + index); // 删除后索引仍有效 // 新vec[1] = 15 ``` #### 6. **批量删除的优化方法（擦除-移除惯用法）** ```cpp std::vector<int> vec = {1,2,3,4,5}; // 先标记要删除的元素 auto new_end = std::remove_if(vec.begin(), vec.end(), [](int x){ return x%2==0; }); // 再批量删除 vec.erase(new_end, vec.end()); // vec变为{1,3,5} ``` #### 关键原则总结 | **操作类型** | **风险** | **安全做法** | |-------------|------------------------|---------------------------------| | 尾部插入 | 可能重新分配内存 | 预分配空间(`reserve()`) | | 中间插入 | 元素移动导致失效 | 使用`insert()`返回值更新迭代器 | | 删除元素 | 后续迭代器失效 | 使用`erase()`返回值更新迭代器 | | 批量操作 | 多次迭代器失效 | 使用"擦除-移除"惯用法 | > **重要提示**：当需要频繁在中间位置插入/删除时，考虑改用`std::list`，其迭代器在插入删除时保持有效（被删除元素除外）[^1][^2]。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值