c++容器中迭代器失效问题介绍，通常情况下如何避免问题发生？多线程下如何避免？

达克豪斯

已于 2023-05-17 22:18:31 修改

阅读量1.1k

点赞数 2

分类专栏： C++ 文章标签： c++ 容器

于 2023-05-17 22:14:21 首次发布

本文链接：https://blog.youkuaiyun.com/weixin_40741460/article/details/130735811

版权

C++ 专栏收录该内容

11 篇文章

订阅专栏

2.3.使用 reserve() 预分配内存

1.问题介绍

迭代器失效是指在使用 C++ 容器操作过程中，迭代器可能因为容器的改变而失去其有效性的情况。失效的迭代器往往会导致程序出现未定义行为。迭代器失效主要有以下几类：

1.1.插入操作导致迭代器失效

当插入元素到容器中时，可能会导致容器内存重新分配。在重新分配后，原有迭代器可能失效。例如，向 vector 和 string 插入元素：

std::vector<int> vec = {1, 2, 3};
auto iter = vec.begin();
vec.insert(vec.begin() + 1, 42);
// 此时，iter 可能失效。

1.2.删除操作导致迭代器失效

当从容器中删除元素时，被删除元素之后的所有迭代器都会失效。例如，从 list 和 vector 中删除元素：

#include <iostream>
#include <list>
using namespace std;

int main() {
    list<int> lst = {1, 2, 3, 4, 5};
    auto it = lst.begin();
    ++it; // 移动迭代器到第二个元素
    lst.erase(it); // 删除第二个元素
    cout << *it << endl; // 输出第二个元素，预期输出为 3，但实际输出为垃圾值
    return 0;
}

在上面的例子中，使用 std::list 容器定义了一个整数数组，并使用 begin 函数获取了一个迭代器。然后，使用 erase 函数删除了第二个元素。最后，输出了第二个元素的值。预期输出为 3，但实际输出为垃圾值，这是因为删除操作导致原本指向第二个元素的迭代器失效，指向了下一个元素。

1.3.容器内存收缩导致迭代器失效

当容器收缩内存时，元素会被重新分配，导致迭代器失效。例如，使用 shrink_to_fit() 收缩 vector：

std::vector<int> vec = {1, 2, 3};
auto iter = vec.begin();
vec.shrink_to_fit();
// 此时，iter 可能失效。

2.如何避免

为了避免迭代器失效，可以采取以下措施：

2.1.在插入和删除操作后刷新迭代器

在插入或删除元素后，重新获取迭代器。例如：

std::vector<int> vec = {1, 2, 3};
auto iter = vec.begin();
vec.insert(vec.begin() + 1, 42);
iter = vec.begin();  // 刷新迭代器

2.2.使用稳定的容器

使用不会导致其他迭代器失效的容器，如 list 和 forward_list。这些容器的插入和删除操作不会影响其他迭代器。

2.3.使用 `reserve()` 预分配内存

对于 vector 和 string 等需要动态分配内存的容器，可以使用 reserve() 预先分配足够的内存，从而避免在插入元素时重新分配内存导致迭代器失效。

2.4.使用迭代器而非下标操作

在循环中删除元素时，使用迭代器而非下标操作。例如：

std::vector<int> vec = {1, 2, 3, 4, 5};
for (auto iter = vec.begin(); iter != vec.end(); /*empty*/) {
  if (*iter % 2 == 0) {
    iter = vec.erase(iter);  // 更新迭代器
  } else {
    ++iter;
  }
}

遵循以上措施，可以避免 C++ 中的迭代器失效问题。

3.多线程下如何避免此类问题发生

在多线程环境下，避免迭代器失效是一个更加复杂的问题。由于多个线程可能同时修改容器中的元素，会导致迭代器失效的风险更大。为了避免迭代器失效问题，可以采取以下几种方法：

3.1.使用互斥锁

在多线程环境下，使用互斥锁可以保证同一时间只有一个线程能够访问容器，从而避免多个线程同时修改容器中的元素导致迭代器失效的问题。在访问容器时，需要先加锁，操作完成后再释放锁。

以下是一个使用互斥锁避免迭代器失效的例子：

#include <iostream>
#include <vector>
#include <mutex>
#include <thread>
using namespace std;

vector<int> vec;
mutex mtx;

void add_elem(int elem) {
    lock_guard<mutex> lock(mtx);
    vec.push_back(elem);
}

int main() {
    thread t1(add_elem, 1);
    thread t2(add_elem, 2);
    t1.join();
    t2.join();
    for (auto it = vec.begin(); it != vec.end(); ++it) {
        cout << *it << " ";
    }
    cout << endl;
    return 0;
}

在上面的例子中，使用互斥锁保护了容器的访问，避免了多个线程同时修改容器中的元素导致迭代器失效的问题。

3.2.使用线程安全的容器

C++11 标准库中提供了一些线程安全的容器，例如 std::atomic、std::mutex、std::condition_variable 等。使用这些容器可以避免多个线程同时访问容器导致的迭代器失效问题。

以下是一个使用 std::atomic 避免迭代器失效的例子：

#include <iostream>
#include <vector>
#include <atomic>
#include <thread>
using namespace std;

vector<int> vec;
atomic<int> idx{0};

void add_elem(int elem) {
    vec[idx++] = elem;
}

int main() {
    vec.resize(2);
    thread t1(add_elem, 1);
    thread t2(add_elem, 2);
    t1.join();
    t2.join();
    for (auto it = vec.begin(); it != vec.end(); ++it) {
        cout << *it << " ";
    }
    cout << endl;
    return 0;
}

在上面的例子中，使用 std::atomic 保证了 idx 的原子性，避免了多个线程同时访问 idx 导致迭代器失效的问题。

总之，在多线程环境下，避免迭代器失效是一个更加复杂的问题。使用互斥锁或线程安全的容器可以避免多个线程同时修改容器中的元素导致迭代器失效的问题。