C++：迭代器失效

C++ 迭代器失效全解析（原因+场景+解决方案）

迭代器失效是C++容器使用中最常见的坑之一，核心定义是：迭代器指向的内存位置（或容器的内部结构）发生了非法改变，导致后续对该迭代器的解引用、递增/递减等操作触发未定义行为（如程序崩溃、数据错乱）。

迭代器本质是"容器元素的指针/索引抽象"，当容器的底层内存布局、元素位置被修改时，迭代器就会失去对有效元素的指向，这就是"失效"。

一、迭代器失效的核心原因

迭代器失效的根本是容器底层结构被破坏，主要分为两类：

1. 内存重分配：容器扩容时，原有内存被释放并重新分配（如vector扩容），迭代器指向的旧内存地址失效；
2. 元素位置改变/删除：容器内元素的物理位置移动（如vector插入元素）、元素被删除，导致迭代器指向的位置不再是原元素（或变为空）。

二、不同容器的迭代器失效场景（高频考点）

不同容器的底层数据结构不同，迭代器失效的场景差异极大，以下是面试/实战中最常考的容器：

1. 顺序容器（vector/deque/string）

（1）vector（动态数组）

操作	迭代器失效情况	原因
push_back()/emplace_back()	仅当容器扩容时，所有迭代器/指针/引用失效 ；未扩容时，仅end()迭代器失效	扩容会重新分配内存，旧内存被释放；未扩容时，尾部插入不影响已有元素，但end()指向的位置改变
insert(pos, ...)	插入位置后的所有迭代器失效；若扩容，所有迭代器失效	插入元素导致后续元素后移，位置改变；扩容则内存重分配
erase(pos)	被删除位置及之后的所有迭代器失效	后续元素前移，被删除位置的迭代器指向无效，后续迭代器指向的元素位置改变
clear()	所有迭代器失效	所有元素被删除，迭代器无有效指向

示例（vector迭代器失效）：

#include <vector>
using namespace std;

int main() {
    vector<int> vec = {1,2,3,4};
    auto it = vec.begin() + 1; // 指向2
    
    vec.erase(it); // 删除2，it失效（指向原位置，现在是3，但迭代器已非法）
    // *it = 10; // 未定义行为：解引用失效的迭代器，可能崩溃
    
    // 正确做法：用erase的返回值更新迭代器
    it = vec.begin() + 1; // 重新指向3
    it = vec.erase(it);   // erase返回下一个有效迭代器（指向4）
    return 0;
}

（2）string（字符数组，同vector逻辑）

insert/erase/append等操作触发内存重分配或元素移动时，迭代器失效，规则与vector完全一致。

（3）deque（双端队列）

• 头部/尾部插入/删除：仅end()迭代器失效，其他迭代器仍有效；
• 中间插入/删除：所有迭代器失效；
• 扩容：所有迭代器失效（deque的内存是分段的，扩容可能重组分段）。

2. 关联容器（map/set/multimap/multiset）

关联容器底层是红黑树（节点式结构），迭代器失效场景极少：

操作	迭代器失效情况	原因
insert()	所有迭代器均有效（仅end()可能失效）	红黑树插入节点仅调整结构，不移动已有节点，迭代器指向的节点内存不变
erase(pos)	仅被删除的迭代器失效，其他迭代器均有效	删除节点仅释放该节点内存，其他节点位置不变

示例（map迭代器失效）：

#include <map>
using namespace std;

int main() {
    map<int, string> mp = {{1,"a"},{2,"b"},{3,"c"}};
    auto it = mp.find(2); // 指向{2,"b"}
    
    mp.erase(it); // it失效，其他迭代器（如指向1、3的）仍有效
    // *it; // 未定义行为：解引用失效的迭代器
    
    // 正确做法：删除前记录下一个迭代器
    for (auto it = mp.begin(); it != mp.end(); ) {
        if (it->first == 3) {
            mp.erase(it++); // 先++获取下一个迭代器，再删除当前
        } else {
            ++it;
        }
    }
    return 0;
}

3. 无序容器（unordered_map/unordered_set）

底层是哈希表（桶+链表/红黑树），迭代器失效场景：

操作	迭代器失效情况	原因
insert()	仅当哈希表扩容（负载因子超限）时，所有迭代器失效；未扩容时，仅end()失效	扩容会重新哈希并分配桶，迭代器指向的旧桶位置失效
erase(pos)	仅被删除的迭代器失效，其他迭代器有效	删除仅释放当前节点，哈希表结构未变

三、迭代器失效的解决方案（实战避坑）

1. 核心原则：操作后更新迭代器

• erase操作 ：利用erase的返回值（指向删除位置的下一个有效迭代器）更新迭代器；

  // vector正确删除元素（避免迭代器失效）
  for (auto it = vec.begin(); it != vec.end(); ) {
      if (*it == 2) {
          it = vec.erase(it); // 用返回值更新迭代器
      } else {
          ++it;
      }
  }

• insert操作 ：插入后重新获取迭代器（或利用insert返回值）；

  auto it = vec.insert(vec.begin()+1, 10); // insert返回指向新元素的迭代器

2. 避免在循环中复用失效迭代器

• 不要在容器修改操作（insert/erase/resize）后，使用之前保存的迭代器；
• 若需多次访问，每次操作后重新获取迭代器（如it = vec.find(xxx)）。

3. 选择合适的容器

• 若需频繁插入/删除且要求迭代器稳定：优先用list（双向链表，所有插入/删除仅失效被删迭代器）、map/set（红黑树，迭代器稳定性高）；
• 若需随机访问：用vector，但需注意扩容/插入后的迭代器更新。

4. 禁用失效迭代器的所有操作

迭代器失效后，*禁止解引用（it）、递增（++it）、递减（--it） 等任何操作，即使程序暂时不崩溃，也属于未定义行为，后续可能触发隐蔽bug。

四、迭代器失效的典型坑点

1. 循环中直接erase迭代器 ：

   // 错误：erase后it失效，++it触发未定义行为
   for (auto it = vec.begin(); it != vec.end(); ++it) {
       if (*it == 2) vec.erase(it);
   }

2. 扩容后复用旧迭代器 ：

   vector<int> vec;
   auto it = vec.begin();
   for (int i=0; i<10000; i++) vec.push_back(i); // 触发扩容，it失效
   *it = 10; // 崩溃：解引用失效迭代器

3. map遍历删除时未保存下一个迭代器 ：

   // 错误：erase(it)后it失效，++it非法
   for (auto it = mp.begin(); it != mp.end(); ++it) {
       if (it->first == 2) mp.erase(it);
   }

总结（核心要点回顾）

1. 迭代器失效定义：迭代器指向的内存/元素位置非法，操作该迭代器触发未定义行为；
2. 失效核心原因：容器内存重分配（vector扩容）、元素位置移动（vector插入）、元素删除；
3. 关键解决方案 ：
   • 顺序容器（vector/deque）：用erase/insert的返回值更新迭代器；
   • 关联容器（map/set）：删除前保存下一个迭代器，仅失效被删迭代器；
   • 避免复用修改操作后的旧迭代器。