C++迭代器失效

在STL中，有些操作会导致迭代器失效，即之前获取的迭代器无法再安全地使用。这是因为这些操作可能会改变容器的结构，例如插入、删除元素等。

具体来说，以下情况下迭代器会失效：

1. 当插入或删除元素导致容器中的内存重新分配时，所有指向容器元素的迭代器都会失效。这是因为容器重新分配了内存空间，原来的迭代器指向的内存已经无效。
2. 当插入元素导致迭代器位置被移动时，被移动的迭代器和之后的所有迭代器都会失效。这是因为插入元素后，容器中的元素位置发生了改变。
3. 当删除元素导致迭代器位置被移动或失效时，被删除元素的迭代器和之后的所有迭代器都会失效。这是因为删除元素后，容器中的元素位置发生了改变或者被删除的元素迭代器已经不存在。
4. 当对容器进行排序操作时，迭代器的相对顺序可能发生变化，因此之前的迭代器可能会失效。

为避免迭代器失效，可以采取以下策略：

1. 尽量避免在循环中进行插入和删除元素的操作。如果必须进行这些操作，可以使用插入和删除后返回新的迭代器，而不是继续使用之前的迭代器。
2. 在遍历容器时，尽量使用前向迭代器或双向迭代器，避免使用随机访问迭代器。因为前向迭代器和双向迭代器的失效范围更小，而随机访问迭代器的失效范围更大。
3. 在可能引起迭代器失效的操作之后，务必更新迭代器，保证它们仍然指向有效的位置。
4. 如果需要在迭代器失效的情况下继续操作容器，可以使用容器提供的索引值或其他标识来重新获取迭代器。

总之，迭代器失效是在使用STL容器时需要注意的问题，了解容器操作可能引起迭代器失效的情况，能够帮助避免潜在的错误。在编写代码时，建议谨慎使用迭代器，并在操作容器后适时更新迭代器，以确保程序的正确性。

4.1 示例

4.1.1 插入操作导致的迭代器失效

<1> vector 容器

std::vector<int> v{1, 2, 3, 4, 5};
auto it = v.begin();

v.insert(it + 2, 9); // 在迭代器位置之前插入元素

// 插入元素后，原来的迭代器`it`已经失效，需要重新获取迭代器
it = v.begin();

for (; it != v.end(); ++it) {
    std::cout << *it << " ";
}

输出结果：1 2 9 3 4 5

在vector容器中，插入元素后，原来的迭代器会失效，因为插入元素后，可能会导致容器重新分配内存，迭代器指向的位置被移动。

<2> list容器

std::list<int> lst{1, 2, 3, 4, 5};
auto it = lst.begin();

lst.insert(std::next(it, 2), 9); // 在迭代器位置之后插入元素

// 插入元素后，原来的迭代器`it`仍然有效
for (; it != lst.end(); ++it) {
    std::cout << *it << " ";
}

输出结果：1 2 3 9 4 5

在list容器中，插入元素不会导致迭代器失效，因为list使用链表结构存储元素，插入元素后，原来的迭代器仍然保持有效。

<3> map容器

std::map<int, std::string> m{{1, "one"}, {2, "two"}, {3, "three"}};
auto it = m.begin();

m.insert(std::make_pair(4, "four")); // 插入键值对

// 插入元素后，原来的迭代器`it`仍然有效
for (; it != m.end(); ++it) {
    std::cout << it->first << ":" << it->second << " ";
}

输出结果：1:one 2:two 3:three 4:four

在map容器中，插入元素不会导致迭代器失效。

4.1.2 删除操作导致的迭代器失效

下面是一个示例代码，演示了使用vector容器删除元素操作导致迭代器失效的情况：

#include <iostream>
#include <vector>

int main() {
    std::vector<int> v{ 1, 2, 3, 4, 5, 6 };
    auto it = v.begin();
    while (it != v.end()) {
        if ((*it % 2) == 0) {
            std::cout << "erase " << *it << std::endl;
            v.erase(it); // 删除偶数元素
        }
        else {
            it++;
        }
    }
    return 0;
}

这个程序会遍历vector容器v中的所有元素，如果某个元素是偶数，则删除它。然而，这个程序存在迭代器失效的问题，因为在删除元素后继续使用同一个迭代器进行遍历容器。事实上，运行这个程序会导致Segmentation fault错误，并且程序崩溃。

这个程序的问题在于，在执行v.erase(it)操作后，迭代器it指向的位置已经变为了被删除元素的下一个位置，而不是原来的下一个位置。因此，在使用it进行下一次循环遍历时，会访问到已经被删除的元素，从而导致异常。

vector iterator not incrementable错误通常是因为在使用vector容器的迭代器时出现了问题。这个错误可能由以下几种情况引起：

在循环中对迭代器进行了无效的增量操作。比如，在循环中使用++运算符对迭代器进行递增，但在某些条件下，没有确保迭代器仍然有效。这可能是由于删除元素或修改容器结构导致的。
在使用迭代器之前，对vector容器进行了修改操作。如果在使用迭代器进行遍历之前，对vector容器执行了插入、删除或排序等改变容器大小的操作，那么迭代器可能会失效。

要解决这个错误，可以考虑以下几点：

（1）确保在对迭代器进行增量操作之前，先判断迭代器是否有效。可以使用条件语句（如if）或循环控制语句（如while）来判断迭代器是否指向有效的元素。

要判断迭代器是否有效，可以通过比较迭代器与容器的begin()和end()迭代器进行判断。如果迭代器位于容器范围内，则表示迭代器有效；否则，表示迭代器无效。

以下是几种常见的方法来判断迭代器的有效性：

<1> 使用相等运算符(==或!=)：通过将迭代器与容器的begin()和end()迭代器进行比较来判断迭代器是否位于容器范围内。例如：

std::vector<int> v{1, 2, 3, 4, 5};
auto it = v.begin();

if (it != v.end()) {
    // 迭代器有效
} else {
    // 迭代器无效
}

<2> 使用std::distance()函数：std::distance()函数可以返回两个迭代器之间的距离。通过计算迭代器与容器的begin()和end()迭代器之间的距离，可以判断迭代器是否在容器范围内。例如：

std::vector<int> v{1, 2, 3, 4, 5};
auto it = v.begin();

if (std::distance(it, v.end()) >= 0) {
    // 迭代器有效
} else {
    // 迭代器无效
}

<3> 使用异常处理：有些容器提供了在迭代器失效时抛出异常的机制。例如，std::list容器在删除迭代器指向的元素后，迭代器会失效，并抛出std::list::iterator类型的异常。可以捕获这个异常来判断迭代器是否有效。例如：

std::list<int> lst{1, 2, 3, 4, 5};
auto it = lst.begin();

try {
    // 在此处进行可能导致迭代器失效的操作
} catch (const std::list<int>::iterator& e) {
    // 迭代器无效
}

在使用迭代器时，注意避免对已经失效的迭代器进行操作，以免引发未定义行为。

（2）如果需要对vector容器进行修改操作，建议在遍历容器之前完成所有修改。

（3）如果需要在遍历过程中删除元素，可以使用正确的方式进行删除。可以使用返回新的迭代器的vector::erase()函数，并将其返回值赋值给迭代器，或者使用vector::erase()的重载版本，传递要删除的元素的位置范围。

为了解决这个问题，可以修改程序，使用返回新的迭代器的vector::erase()函数，如下所示：

#include <iostream>
#include <vector>

int main() {
    std::vector<int> v{ 1, 2, 3, 4, 5, 6 };
    auto it = v.begin();
    while (it != v.end()) {
        if ((*it % 2) == 0) {
            std::cout << "erase " << *it << std::endl;
            it = v.erase(it); // 删除偶数元素，并返回新的迭代器
        }
        else {
            it++;
        }
    }
    return 0;
}

输出结果：