C++ 中的迭代器失效及其预防

已于 2024-10-07 17:21:56 修改
阅读量587 收藏 4
点赞数 17
分类专栏： C++ 文章标签： c++
于 2024-10-07 17:21:15 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43414962/article/details/142738819
版权

1. 什么是迭代器失效？

在 C++ 中，迭代器是一种用于遍历容器元素的对象。当容器发生了某些操作（如插入、删除、内存重新分配）时，这些操作可能会使得迭代器失效。失效的迭代器指向的内存可能已经被释放或更改，导致程序行为未定义，如输出异常结果、程序崩溃等。

2. 迭代器失效的常见原因

迭代器失效的常见原因包括：

内存重新分配：对于 std::vector，如果插入新元素导致当前容量 (capacity) 不足，则会重新分配内存空间，从而导致所有指向该 vector 元素的迭代器失效。
元素插入或删除：对于某些容器（如 std::vector、std::deque 和 std::map），插入或删除元素会导致迭代器失效。
容器清空或销毁：clear 操作会使得所有的迭代器失效，而容器销毁则会使所有指向容器元素的迭代器变为悬空指针。

3. 各种容器中迭代器失效的特性

std::vector:

插入元素时，如果 size 超过 capacity，则 std::vector 重新分配内存，所有迭代器失效。
删除或插入元素时，位置及其之后的迭代器失效。

std::map 和 std::set:

删除某个元素时，指向被删除元素的迭代器失效，但其他迭代器不受影响。
插入新元素时，不会导致任何迭代器失效。

std::list:

插入和删除元素不会影响其他迭代器，因为 std::list 的底层实现是双向链表，内存分配是非连续的。

4. 示例代码：迭代器失效及预防策略

下面通过一系列代码示例来演示迭代器失效的情况、其排查方法以及如何编程预防。

示例 1：std::vector 中的迭代器失效（插入元素导致内存重新分配）

#include <iostream>
#include <vector>

int main() {
    std::vector<int> numbers;
    numbers.reserve(2);  // 预先分配2个元素的空间

    // 插入两个元素并保存一个迭代器
    numbers.push_back(1);
    numbers.push_back(2);

    auto it = numbers.begin(); // 保存第一个元素的迭代器

    std::cout << "Initial capacity: " << numbers.capacity() << "\n";
    std::cout << "Address of iterator before reallocation: " << &(*it) << "\n";
	std::cout << "Value of iterator before reallocation: " << *it << "\n";
	
    // 插入第三个元素导致内存重新分配
    numbers.push_back(3);
    std::cout << "Capacity after adding third element: " << numbers.capacity() << "\n";
    std::cout << "Address of iterator after reallocation: " << &(*it) << "\n"; // 输出已失效的迭代器地址

    // 检查迭代器是否仍然有效
    try {
        std::cout << "Value of iterator after reallocation: " << *it << "\n";
    } catch (...) {
        std::cout << "Iterator is invalid after reallocation!\n";
    }

    return 0;
}
输出结果
Initial capacity: 2
Address of iterator before reallocation: 0x55a6843de270
Value of iterator before reallocation: 1
Capacity after adding third element: 4
Address of iterator after reallocation: 0x55a6843de270
Value of iterator after reallocation: 0
分析：

插入第三个元素时，std::vector 的 capacity 从 2 变为 4，发生了内存重新分配，导致原先的迭代器 it 失效。失效后的 it 指向的内存地址仍然是原来的位置，但其指向的内容已发生变化（原本内容是1，此时变成了0），就已经证明it迭代器失效了。
内存重新分配可能导致迭代器指向的地址偶然与之前相同，但其指向的内容已经变得无效，因此不能依赖地址是否相同来判断迭代器是否失效。
正确处理内存重新分配后的迭代器是确保代码安全和稳定的重要手段。每当发生可能导致迭代器失效的操作时（如 reserve、push_back），都应重新获取迭代器以避免未定义行为。

修正方案：
#include <iostream>
#include <vector>

int main() {
    std::vector<int> numbers;
    numbers.reserve(4);  // 预先分配4个元素的空间

    // 插入两个元素并保存一个迭代器
    numbers.push_back(1);
    numbers.push_back(2);

    auto it = numbers.begin(); // 保存第一个元素的迭代器

    std::cout << "Initial capacity: " << numbers.capacity() << "\n";
    std::cout << "Address of iterator before reallocation: " << &(*it) << "\n";
    std::cout << "Value of iterator before reallocation: " << *it << "\n";

    // 插入第三个元素,此时容量足够，不会触发自动重新分配内存
    numbers.push_back(3);
    std::cout << "Capacity after adding third element: " << numbers.capacity() << "\n";
    std::cout << "Address of iterator after reallocation: " << &(*it) << "\n"; // 输出已失效的迭代器地址

    // 检查迭代器是否仍然有效
    try {
        std::cout << "Value of iterator after reallocation: " << *it << "\n";
    } catch (...) {
        std::cout << "Iterator is invalid after reallocation!\n";
    }

    return 0;
}
输出结果
Initial capacity: 4
Address of iterator before reallocation: 0x5615233b3270
Value of iterator before reallocation: 1
Capacity after adding third element: 4
Address of iterator after reallocation: 0x5615233b3270
Value of iterator after reallocation: 1

可以看到此时it迭代器并没有失效。

示例 2：在 std::vector 中删除元素导致迭代器失效

#include <iostream>
#include <vector>

int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5};

    // 尝试在遍历过程中删除元素
    for (auto it = numbers.begin(); it != numbers.end(); ++it) {
        if (*it == 3) {
            numbers.erase(it); // 删除元素 3
            // 此时 it 失效，指向已删除的位置，继续递增会引发未定义行为
        }
    }

    // 可能导致程序崩溃或输出异常结果
    for (const auto& num : numbers) {
        std::cout << num << " ";
    }

    std::cout << "\n";
    return 0;
}
输出结果
1 2 4 5

脸疼！！！（微笑狗头），让俺解释一下，这个是迭代器失效问题比较难的一点，就是它有时候表现的不明显，甚至输出结果都没问题，但是上面的代码依然是一段危险的代码。

从理论上说：

在 std::vector 中，当我们调用 erase(it) 删除某个元素时：
1、该迭代器 it 立即失效，因为它指向的元素已经从容器中移除。
2、删除操作会导致该元素后面的所有元素向前移动，以填补被删除元素的空位。
3、因此，指向 vector 中其他元素的所有迭代器（从 it 开始，到 end() 之间的迭代器）也会失效。

在上面的代码中，erase(it) 返回一个指向删除元素 之后 的新迭代器。但我们并没有保存这个返回值，而是继续使用原始的迭代器 it，因此会导致 迭代器失效 问题。

为什么结果看起来没有发生错误？

有以下几种原因：

1. 未定义行为并不总是立即显现：

迭代器失效引发的未定义行为（UB）可能表现为程序崩溃、数据错误、内存访问异常等，但并不一定每次运行都能观察到。
有时，程序运行时即使发生了迭代器失效，内存布局未发生变化，因此访问失效迭代器时看似没有问题，但这依然是 不安全的代码。

2. 编译器和优化器的影响：

在不同编译器（如 GCC、Clang 或 MSVC）和不同编译优化等级下（如 -O0、-O2），编译器可能对代码行为有不同处理。
特定情况下，编译器可能对 vector 内存布局的操作不会立即触发未定义行为，导致看似代码能够正常运行。

3. 正确的解决方案

为了防止迭代器失效，在删除元素时应当使用 erase 返回的新迭代器，并将其重新赋值给 it，以确保它指向删除后正确的位置。代码可以修改如下：

使用 erase 操作后，直接将迭代器更新为 erase 的返回值。

#include <iostream>
#include <vector>

int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5};

    for (auto it = numbers.begin(); it != numbers.end(); /* 空 */) {
        if (*it == 3) {
            it = numbers.erase(it); // 删除后更新迭代器
        } else {
            ++it; // 仅当未删除时递增迭代器
        }
    }

    // 输出结果：1 2 4 5
    for (const auto& num : numbers) {
        std::cout << num << " ";
    }

    std::cout << "\n";
    return 0;
}

修改后输出结果

1 2 4 5

为了更好地验证迭代器失效问题，可以在删除操作后，尝试访问失效迭代器，并通过调试工具或者断言检查迭代器状态。例如：

#include <iostream>
#include <vector>
#include <cassert> // 用于断言检查

int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5};

    // 记录删除前的指向第3个元素的迭代器
    auto it = numbers.begin() + 2;
    std::cout << "Address before erase: " << &(*it) << "\n";

    // 删除元素 3，并保存返回的新迭代器
    auto new_it = numbers.erase(it);

    // 断言：原始迭代器指向的内存不应该再被访问
    std::cout << "Address after erase: " << &(*new_it) << "\n"; 
    assert(new_it != it);  // 检查 new_it 与旧的 it 是否相同（相同则表示逻辑错误，it 不应该仍然有效）

    std::cout << "New iterator value: " << *new_it << "\n";  // 输出 4

    return 0;
}
输出结果
Address before erase: 0x55cbd9aad278
Address after erase: 0x55cbd9aad278
a.out: test.cpp:17: int main(): Assertion `new_it != it' failed.
Aborted (core dumped)

这个断言用来确保 new_it 和 it 指向不同的内存位置。
如果 erase 操作成功，则 new_it 应该指向 4，而 it 应该已经失效（不再指向有效的元素）。
如果断言失败，表示 new_it 和 it 的值相等，即二者都指向同一个位置，这意味着迭代器没有正确更新，可能表明程序中存在逻辑错误。
综上所述，示例2第一段代码确实发生了迭代器失效问题，只是结果上没有发生错误，需要我们在编程时，细心注意，避免这种隐藏的错误，健壮我们的代码。

示例 3：std::map 中删除元素导致迭代器失效

#include <iostream>
#include <map>

int main() {
    std::map<int, std::string> data = {{1, "A"}, {2, "B"}, {3, "C"}, {4, "D"}};

    for (auto it = data.begin(); it != data.end(); ++it) {
        if (it->first == 3) {
            data.erase(it); // 删除键值为 3 的元素
            // it 失效，后续使用时会引发未定义行为
        }
    }
    
   	for (const auto& pair : data) {
        std::cout << pair.first << ": " << pair.second << "\n";
    }

    return 0;
}
修正方案：

道理和示例2是一样的，要使用 erase 的返回值来更新迭代器。

#include <iostream>
#include <map>

int main() {
    std::map<int, std::string> data = {{1, "A"}, {2, "B"}, {3, "C"}, {4, "D"}};

    for (auto it = data.begin(); it != data.end(); /* 空 */) {
        if (it->first == 3) {
            it = data.erase(it); // 删除后使用 erase 返回的迭代器
        } else {
            ++it;
        }
    }

    // 输出结果：1: A, 2: B, 4: D
    for (const auto& pair : data) {
        std::cout << pair.first << ": " << pair.second << "\n";
    }

    return 0;
}

5. 预防迭代器失效的策略

  1. 预先分配内存：对于 std::vector，可以使用 reserve 预先分配足够的内存，避免频繁的内存重新分配。
  2. 使用返回值更新迭代器：在 erase 或 insert 后，使用返回值来更新迭代器。
  3. 重新获取迭代器：在可能引起迭代器失效的操作后，重新获取迭代器而不是继续使用旧的迭代器。

6. 总结

在 C++ 中，迭代器失效是一个常见问题，尤其是在修改容器元素时。理解迭代器失效的原因并使用相应的预防策略可以避免潜在的错误和未定义行为。在实际编程中，应尽量遵循安全的迭代器操作规则，并在多次修改容器结构时，始终注意迭代器、指针或引用的有效性。

找不着地窖的皮险家
关注
专栏目录
C++迭代器失效
m0_71526157的博客
06-04 1997
在C++中，迭代器是一种方便遍历容器元素的工具，可以允许我们通过指针的方式来遍历容器，并在遍历的同时对容器的元素进行添加、删除、修改等操作。但是在对容器进行修改的过程中，很容易导致迭代器失效，从而引起程序崩溃或产生不可预期的结果。因此在使用迭代器遍历容器时，需要注意迭代器的有效性及时更新相关的迭代器。
c++迭代器失效的情况汇总
08-19
C++迭代器失效的情况汇总 C++迭代器失效是指在使用容器时，迭代器失去了指向正确元素的能力，而导致程序出错或崩溃。这种情况在C++编程中非常常见，尤其是在使用STL容器时。了解迭代器失效的情况可以帮助我们更好地...
C++—迭代器失效
拥抱技术
08-31 982
迭代器失效
【C++】容器的迭代器失效问题
Colorful___的博客
01-22 1310
迭代器失效问题是 C++ 程序设计中一个常见的问题。在使用容器进行添加/删除元素的操作时，指向容器元素的指针、引用或迭代器可能会失效，这将导致严重的程序错误。为了避免迭代器失效，我们需要了解哪些操作可能会导致迭代器失效，以及如何管理迭代器。
C++迭代器失效问题
2301_76197086的博客
05-13 357
详解C++迭代器失效问题
531-C++迭代器失效问题及解决方法
LINZEYU666的博客
09-09 1078
为什么方式都是一样？因为迭代器遍历完当前元素跳到下一个元素，底层数据结构的具体的遍历方式都封装在这个迭代器的++运算符函数了。 所以，作为使用方，我们不需要知道底层的数据结构原理。 我们只知道底层数据元素的遍历都封装在++运算符重载函数里面。 迭代器一般实现成容器的嵌套类型 只有容器底层数据结构内存是连续的，才提供[]运算符的重载 对于vector来说，我们可以通过[]运算符重载函数遍历访问容器，也可以定义迭代器访问容器，也可以使用for_each访问容器 ...
【C++】迭代器失效问题
qq_45666995的博客
02-19 434
迭代器（iterator）是一个可以对其执行类似指针的操作（如：解引用 operator*() 、自增 operator++() 的对象，我们可以将它理解成为一个指针，但它又不是我们所谓普通的指针，我们可以称之为广义指针。相比顺序结构（vector、string等），list无法通过[i]的方式进行随机访问，迭代器的出现便方便了链表等非顺序数据结构的遍历操作。
C++ STL --- vector之迭代器失效
weixin_57761086的博客
08-28 1718
讲解C++ STL vector的迭代器失效。用简单的方式解决1.什么是迭代器失效？ 2.vector哪些操作会导致迭代器失效？ 3.如何避免迭代器失效？这三个问题。
C/C++迭代器失效问题
qq_45326605的博客
03-25 2300
文章目录前言迭代器失效总结 前言 我今天在使用迭代器时发现了一个问题，这个问题就是我在使用的迭代器时发现莫名其妙的有越界访问和获取的位置跟预期不符，经过一天的排查我发现不是所有情况下会出现这种问题，而是在容器删除和扩容时会发生越界或结果和预期不符的情况。 下面是我今天做的一些代码测试： Text1 该函数的功能是把数组里面的所有偶数删除，遍历方式使用的是迭代器。 #include <iostream> #include <vector> #include <algorithm&
C++ 迭代器失效
weixin_53946312的博客
08-05 347
迭代器失效 迭代器失效实际就是迭代器底层对应指针所指向的空间被销毁了，而使用一块已经被释放的空间 迭代器失效有两种情况 1、意义改变 2、崩溃出现野指针 引起失效的操作： 1、指定位置元素的删除操作 void test_vector4() { vector<int> v; v.push_back(1); v.push_back(2); v.push_back(3); v.push_back(4); v.push_back(5); for (auto e : v) { cout
C++ STL迭代器失效问题
zsiming的博客
09-15 1878
在STL里面的容器往往封装了迭代器。迭代器能让人很方便的拿到容器里面的元素进行操作。然而，在不同结构的容器中，删除一个迭代器可能会引发迭代器失效的问题。下面针对不同的容器类型做一下总结。
浅谈c++ stl迭代器失效的问题
12-26
之前看《C++ Primier》的时候，也解到在顺序型窗口里insert/erase会涉及到迭代器失效的问题，并没有深究。今天写程序的时候遇到了这个问题。 1 莫名其妙的Erase 最初我的程序是酱紫的，别说话，我知道这样是有问题的...
[c语言]一句话讲清循环中break和continue的作用与区别
2303_77060768的博客
09-29 163
1.两者的作用break和contuinue都只能在循环中使用，都用来停止循环。​​​​​​​2.两者的区别break在循环中只要遇到break，就直接永久终止当前循环，开始执行当前循环之外的代码。在循环中只要遇到continue，就结束本次循环，继续进行下一次循环。
【C语言】数据类型和变量
最新发布
2302_76713442的博客
10-06 1022
一、数据类型分类（内置数据类型：字符型、整型、浮点型和布尔类型）（自定义数据类型：数组、结构体、枚举和联合体）二~三、深入研究内置数据类型（内置数据类型的大小、使用内置数据类型创建变量、signed 和 unsigned）四、自定义数据类型的内容过于庞大，所以每种自定义数据类型都专门写了一篇博客来介绍，文中有相应链接。
第 21 章 一条记录的多幅面孔——事务的隔离级别与 MVCC
weixin_45740473的博客
10-02 960
并发的事务在运行过程中会出现一些可能的引发一致性问题SQL 标准中有4种隔离级别版本链ReadView。
C - Separated Lunch
m0_74304371的博客
10-05 260
C - Separated Lunch(KEYENCE Programming Contest 2024 (AtCoder Beginner Contest 374))
【C语言】字符函数和字符串函数(1)
hdxbufcbjuhg的博客
09-28 1718
str是\0了，循环是照常结束，但是str还要++一次，str就指向\0后面了，根据我们前面的分析就是错误的，所以这里只能把str自增的语句写在循环体内，当然，如果是拷贝字符串则不用担心这一点，可以放心把自增写在循环判断条件中。原型解析：strcpy的第一个参数是我们拷贝字符串的目的地的首地址，也就是接收拷贝的数组的首元素地址，第二个参数是我们拷贝字符串的源字符串的首地址，它的返回值就是接收拷贝的目标空间的初始地址。strcmp的作用就是帮我们比较两个字符串的大小，那么比较的依据是什么呢？
【C++】类与对象基础概念解析
A Charmer 的博客
10-03 1374
在 C++ 编程中，类与对象是核心概念之一，它们为程序设计提供了一种强大而灵活的方式来组织代码和管理数据。理解类与对象的基础概念对于掌握 C++ 编程至关重要。
C语言 | Leetcode C语言题解之第448题找到所有数组中消失的数字
m0_59237910的博客
10-01 410
C语言 | Leetcode C语言题解之第448题找到所有数组中消失的数字
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值