C++浅谈STL容器迭代器失效

参考：https://blog.csdn.net/wangshihui512/article/details/9791517

https://blog.csdn.net/petersmart123/article/details/53304437

 

序列性容器::(vector和list和deque) 
        erase迭代器不仅使所指向被删元素的迭代器失效，而且使被删元素之后的所有迭代器失效，所以不能使用erase(iter++)的方式，但是erase的返回值为下一个有效的迭代器。

        所以正确方法为::
        for( iter = c.begin(); iter != c.end(); )
              iter = c.erase(iter);
 
关联性容器::(map和set比较常用)
        erase迭代器只是被删元素的迭代器失效，但是返回值为void，所以要采用erase(iter++)的方式删除迭代器，  
        所以正确方法为::
        for( iter = c.begin(); iter != c.end(); )  
              c.erase(iter++);

 

删除map<int, int>中value为5的倍数的元素。 该题看起来很自然很简单， 实则有迭代器失效的陷阱。如果对迭代器失效问题一无所知， 则很容易写出如下的错误代码：

#include <iostream>
 2 #include <map>
 3 using namespace std;
 4 
 5 typedef map<int, int> Map;
 6 typedef map<int, int>::iterator MapIt;
 7 
 8 void print(Map &m)
 9 {
10     MapIt it;
11     for(it = m.begin(); it != m.end(); it++)
12     {
13         cout << it->second << " ";
14     }
15 
16     cout << endl;
17 }
18 
19 void deleteValueFromMap(Map &m, int n = 5)
20 {
21     MapIt it;
22     for(it = m.begin(); it != m.end(); it++)
23     {
24         if(0 == it->second % n)
25         {
26             m.erase(it);
27         }
28     }
29 }
30 
31 int main()
32 {
33     Map m;
34     int i = 0;
35     for(i = 0; i < 21; i++)
36     {
37         m[i] = i;
38     }
39 
40     print(m);
41 
42     deleteValueFromMap(m); // 程序崩溃
43 
44     return 0;
45 }

运行上述程序， 结果程序崩溃，什么原因呢？ 原来， 对于关联的容器map来说， m.erase(it);后， it就失效了， 而for循环中有it++, 自然而然会出问题啊。 那怎么办呢？

#include <iostream>
  2 #include <map>
  3 using namespace std;
  4 
  5 typedef map<int, int> Map;
  6 typedef map<int, int>::iterator MapIt;
  7 
  8 void print(Map &m)
  9 {
 10     MapIt it;
 11     for(it = m.begin(); it != m.end(); it++)
 12     {
 13         cout << it->second << " ";
 14     }
 15 
 16     cout << endl;
 17 }
 18 
 19 void deleteValueFromMap(Map &m, int n = 5)
 20 {
 21     MapIt it;
 22     MapIt tmp;
 23     for(it = m.begin(); it != m.end(); /*不能再自增了*/)
 24     {
 25         if(0 == it->second % n)
 26         {
 27             tmp = it++;
 28             m.erase(tmp);
 29         }
 30         else
 31         {
 32             it++;
 33         }
 34     }
 35 }
 36 
 37 int main()
 38 {
 39     Map m;
 40     int i = 0;
 41     for(i = 0; i < 21; i++)
 42     {
 43         m[i] = i;
 44     }
 45 
 46     print(m);
 47 
 48     deleteValueFromMap(m); // 程序ok
 49     print(m);
 50 
 51     return 0;
 52 }
 53        结果为:
 54 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
 55 1 2 3 4 6 7 8 9 11 12 13 14 16 17 18 19

当然， 上述程序也可以继续简化为：

void deleteValueFromMap(Map &m, int n = 5)
 84 {
 85     MapIt it;
 86     for(it = m.begin(); it != m.end(); /*不能再自增了*/)
 87     {
 88         if(0 == it->second % n)
 89         {
 90             m.erase(it++);
 91         }
 92         else
 93         {
 94             it++;
 95         }
 96     }
 97 }

而对于vector

这里就有一个问题，比如《c++ primer》习题9.26，该题目要求如下：

有一个数组int a[] ={0,1,1,2,3,5,8,13,21,55,89};要求将该数组保存到一个vector容器中和一个list容器中，然后将vector容器中的偶数删除，将list容器中的奇数删除，关于本题，该书课后答案核心代码如下：
 

for(list<int>::iterator iter = ilst.begin();
			iter != ilst.end();iter++
			){
			if((*iter) %2 == 1){
			//	int tmp = *iter;
				iter = ilst.erase(iter);
				--iter;
			//	continue;
			}
		//	iter++;
	}

 

这个只是一段核心算法代码，基本上考虑到了该考虑的问题，比如说删除一个元素之后，指针指向该删除元素的后面一个元素，如果循环再加1，就跳过了被删除元素的下一个元素，但是存在一个很严重的问题，我们看Vertor段的代码：

for(vector<int>::iterator iter = ivec.begin();
			iter != ivec.end(); iter++
			){
			if((*iter) %2 == 0){
		//		int tmp = *iter;
				iter = ivec.erase(iter);
				--iter;
		//		continue;
			}
		//	iter++;
	}

然后以第一个数据为例，删除了第一个元素0之后，返回的iter指向下一个元素1，然后做自减运算，这时就出现了问题，前面的元素0已经删除，这个时候自减运算得到的结果就是一个野指针，程序就会出现问题。也就是说上面的代码形式对不同的数据的顺序会产生不同的结果，可能会出错 ，这显然不是我们要的。所以我将代码改为如下形式：
 

for(vector<int>::iterator iter = ivec.begin();
			iter != ivec.end(); //iter++
			){
			if((*iter) %2 == 0){
			//	int tmp = *iter;
				iter = ivec.erase(iter);
			//	--iter;
				continue;
			}
			iter++;
	}

以这样的形式，数据的顺序就不会影响结果，而且也不会出现野指针的问题，考虑到第二个erase()函数，我觉得对erase()函数的用法不能有太大的限制，我们在对容器操作，删除容器内元素，使用erase函数时，需要时刻记住的有两点：
第一个就是erase函数的返回值是一个指向被删除元素的下一个元素的迭代器。

第二点就是使用完erase函数之后的迭代器是否会产生野指针。这样的话在写代码的时候就不会产生很大的问题。