c++之迭代器失效

参考：http://www.cnblogs.com/yuanshuang/p/5777905.html

http://blog.csdn.net/aa838260772/article/details/39678187

序列性容器::(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++);

Tips:
       其实对于list两种方式都可以正常工作

STL的容器删除元素，除了使用迭代器外，还可以使用erase(key)的方式。

size_t rm_num = obj.erase(key);

rm_num标示删除key的成员的个数，在map中key是key值，在其他容器中，key是一个value。

-----------------------------------------------------------------------------------------------------------------

C++迭代器失效的问题汇总 


首先对于vector而言，添加和删除操作可能使容器的部分或者全部迭代器失效。那为什么迭代器会失效呢？vector元素在内存中是顺序存储，试想：如果当前容器中已经存在了10个元素，现在又要添加一个元素到容器中，但是内存中紧跟在这10个元素后面没有一个空闲空间，而vector的元素必须顺序存储一边索引访问，所以我们不能在内存中随便找个地方存储这个元素。于是vector必须重新分配存储空间，用来存放原来的元素以及新添加的元素：存放在旧存储空间的元素被复制到新的存储空间里，接着插入新的元素，最后撤销旧的存储空间。这种情况发生，一定会导致vector容器的所有迭代器都失效。我们看到实现上述所说的分配和撤销内存空间的方式以实现vector的自增长性，效率是极其低下的。为了使vector容器实现快速的内存分配，实际分配的容器会比当前所需的空间多一些，vector容器预留了这些额外的存储区，用来存放新添加的元素，而不需要每次都重新分配新的存储空间。你可以从vector里实现capacity和reserve成员可以看出这种机制。capacity和size的区别：size是容器当前拥有的元素个数，而capacity则指容器在必须分配新存储空间之前可以存储的元素总数。


　　vector迭代器的失效情况：


　　1.当插入（push_back）一个元素后，end操作返回的迭代器肯定失效。


　　2.当插入（push_back）一个元素后，capacity返回值与没有插入元素之前相比有改变，则需要重新加载整个容器，此时begin和end操作返回的迭代器都会失效。


　　3.当进行删除操作（erase,pop_back）后，指向删除点的迭代器全部失效；指向删除点后面的元素的迭代器也将全部失效。


　　deque迭代器的失效情况：


　　1.在deque容器首部或者尾部插入元素不会使得任何迭代器失效。


　　2.在其首部或尾部删除元素则只会使指向被删除元素的迭代器失效。


　　3.在deque容器的任何其他位置的插入和删除操作将使指向该容器元素的所有迭代器失效。


　　List/set/map迭代器的失效情况：


　　删除时，指向该删除节点的迭代器失效


　　list intList;


　　list::iterator it = intList.begin（）；


　　while（it != intList.end（））


　　{


　　it = intList.erase（it）；


　　……


　　}


　　总结各种容器特点


　　（1） vector


　　内部数据结构：数组。


　　随机访问每个元素，所需要的时间为常量。


　　在末尾增加或删除元素所需时间与元素数目无关，在中间或开头增加或删除元素所需时间随元素数目呈线性变化。


　　可动态增加或减少元素，内存管理自动完成，但程序员可以使用reserve（）成员函数来管理内存。


　　vector的迭代器在内存重新分配时将失效（它所指向的元素在该操作的前后不再相同）。当把超过capacity（）-size（）个元素插入vector中时，内存会重新分配，所有的迭代器都将失效；否则，指向当前元素以后的任何元素的迭代器都将失效。当删除元素时，指向被删除元素以后的任何元素的迭代器都将失效。


　　（2）deque


　　内部数据结构：数组。


　　随机访问每个元素，所需要的时间为常量。


　　在开头和末尾增加元素所需时间与元素数目无关，在中间增加或删除元素所需时间随元素数目呈线性变化。


　　可动态增加或减少元素，内存管理自动完成，不提供用于内存管理的成员函数。


　　增加任何元素都将使deque的迭代器失效。在deque的中间删除元素将使迭代器失效。在deque的头或尾删除元素时，只有指向该元素的迭代器失效。


　　（3）list


　　内部数据结构：双向环状链表。


　　不能随机访问一个元素。


　　可双向遍历。


　　在开头、末尾和中间任何地方增加或删除元素所需时间都为常量。


　　可动态增加或减少元素，内存管理自动完成。


　　增加任何元素都不会使迭代器失效。删除元素时，除了指向当前被删除元素的迭代器外，其它迭代器都不会失效。


（4）slist


　　内部数据结构：单向链表。


　　不可双向遍历，只能从前到后地遍历。


　　其它的特性同list相似。


　　（5）stack


　　适配器，它可以将任意类型的序列容器转换为一个堆栈，一般使用deque作为支持的序列容器。


　　元素只能后进先出（LIFO）。


　　不能遍历整个stack.


　　（6）queue


　　适配器，它可以将任意类型的序列容器转换为一个队列，一般使用deque作为支持的序列容器。


　　元素只能先进先出（FIFO）。


　　不能遍历整个queue.


　　（7）priority_queue


　　适配器，它可以将任意类型的序列容器转换为一个优先级队列，一般使用vector作为底层存储方式。


　　只能访问第一个元素，不能遍历整个priority_queue.


　　第一个元素始终是优先级最高的一个元素。


　　（8）set


　　键唯一。


　　元素默认按升序排列。


　　如果迭代器所指向的元素被删除，则该迭代器失效。其它任何增加、删除元素的操作都不会使迭代器失效。


　　（9）multiset


　　键可以不唯一。


　　其它特点与set相同。


　　（10）map


　　键唯一。


　　元素默认按键的升序排列。


　　如果迭代器所指向的元素被删除，则该迭代器失效。其它任何增加、删除元素的操作都不会使迭代器失效。


　　（11）multimap


　　键可以不唯一。


　　其它特点与map相同。


　　1. 容器的iterator类型


　　每种容器类型都定义了自己的迭代器类型，如vector:


　　vector::iterator iter;


　　这条语句定义了一个名为iter的变量，它的数据类型是由vector定义的iterator类型。每个标准库容器类型都定义了一个名为iterator的成员，这里的iterator与迭代器实际类型的含义相同。


　　2. begin和end操作


　　每种容器都定义了一对命名为begin和end的函数，用于返回迭代器。如果容器中有元素的话，由begin返回的迭代器指向第一个元素：


　　vector::iterator iter = ivec.begin（）；


　　上述语句把iter初始化为由名为begin的vector操作返回的值。假设vector不空，初始化后，iter即指该元素为ivec[0].


　　由end操作返回的迭代器指向vector的"末端元素的下一个".通常称为超出末端迭代器（off-the-end iterator），表明它指向了一个不存在的元素。如果vector为空，begin返回的迭代器与end返回的迭代器相同。


　　由end操作返回的迭代器并不指向vector中任何实际的元素，相反，它只是起一个哨兵（sentinel）的作用，表示我们已处理完vector中所有元素。


　　3. vector迭代器的自增和解引用运算


　　迭代器类型定义了一些操作来获取迭代器所指向的元素，并允许程序员将迭代器从一个元素移动到另一个元素。


　　迭代器类型可使用解引用操作符（*操作符）来访问迭代器所指向r 元素：


　　*iter = 0;


　　解引用操作符返回迭代器当前所指向的元素。假设iter指向vector对象ivec的第一个元素，那么*iter和ivec[0]就是指向同一个元素。上面这个语句的效果就是把这个元素的值赋为0.


　　迭代器使用自增操作符向前移动迭代器指向容器中下一个元素。从逻辑上说，迭代器的自增操作和int型对象的自增操作类似。对 int对象来说，操作结果就是把int型值"加1",而对迭代器对象则是把容器中的迭代器"向前移动一个位置".因此，如果iter指向第一个元素，则++iter指向第二个元素。


　　由于end操作返回的迭代器不指向任何元素，因此不能对它进行解引用或自增操作。


　　4. 迭代器的其他运算


　　另一对可执行于迭代器的操作就是比较：用==或！=操作符来比较两个迭代器，如果两个迭代器对象指向同一个元素，则它们相等，否则就不相等。


　　5. 迭代器应用的程序示例


　　假设已声明了一个vector型的ivec变量，要把它所有元素值重置为0,可以用下标操作来完成：


　　// reset all the elements in ivec to 0


　　for （vector::size_type ix = 0; ix != ivec.size（）； ++ix）


　　ivec[ix] = 0;


　　上述程序用for循环遍历ivec的元素，for循环定义了一个索引ix,每循环迭代一次ix就自增1.for循环体将ivec的每个元素赋值为0


　总结：


　　1、对于关联式容器（map, list, set）元素的删除，插入操作会导致指向该元素的迭代器失效，其他元素迭代器不受影响。


　　2、对于顺序式容器（vector）元素的删除、插入操作会导致指向该元素以及后面的元素的迭代器失效。


　　关于迭代器


　　（1）特征与操作


　　l 迭代器的基本特征有：


　　解除--支持解除引用（dereference）操作，以便可以访问它引用的值。即，如果p是一个迭代器，则应该对*p和p->进行定义（似指针）；


　　赋值--可将一个迭代器赋给另一个迭代器。即，如果p和q都是迭代器，则应该对表达式p=q进行定义；


　　比较--可将一个迭代器与另一个迭代器进行比较。即，如果p和q都是迭代器，则应该对表达式p==q和p!=q进行定义；


　　遍历--可以使用迭代器来遍历容器中的元素，这可以通过为迭代器p定义++p和p++操作来实现。


　　迭代器的操作有：


　　读--通过解除引用*来间接引用容器中的元素值，例如x = *p;


　　写--通过解除引用*来给容器中的元素赋值，例如*p = x;


　　访问--通过下标和指向引用容器中的元素及其成员，例如p[2]和p->m


　　迭代--利用增量和减量运算（++和--、+和-、+=和-=）在容器中遍历、漫游和跳跃，例如p++、--p、p+5、p-=8


　　比较--利用比较运算符（==、！=、<、>、<=、>=）来比较两个迭代器是否相等或谁大谁小，例如if（p < q）……；、wihle（p != c.end（））……；


　　（2）分类


　　根据迭代器所支持的操作不同，在STL中定义了如下5种迭代器：


　　l 输入迭代器（input iterator）--用于读取容器中的信息，但不一定能够修改它。


　　输入迭代器iter通过解除引用（即*iter），来读取容器中其所指向元素之值；


　　为了使输入迭代器能够访问容器中的所有元素的值，必须使其支持（前/后缀格式的）++ 操作符；


　　输入迭代器不能保证第二次遍历容器时，顺序不变；也不能保证其递增后，先前指向的值不变。即，基于输入迭代器的任何算法，都应该是单通（single-pass）的，不依赖于前一次遍历时的值，也不依赖于本次遍历中前面的值。


　　可见输入迭代器是一种单向的只读迭代器，可以递增但是不能递减，而且只能读不能写。适用于单通只读型算法。


　　l 输出迭代器（output iterator）--用于将信息传输给容器（修改容器中元素的值），但是不能读取。例如，显示器就是只能写不能读的设备，可用输出容器来表示它。也支持解除引用和++操作，也是单通的。所以，输出迭代器适用于单通只写型算法。


　　l 前向迭代器（forward iterator正向迭代器）--只能使用++操作符来单向遍历容器（不能用--）。与I/O迭代器一样，前向迭代器也支持解除引用与++操作。与I/O迭代器不同的是，前向迭代器是多通的（multi-pass）。即，它总是以同样的顺序来遍历容器，而且迭代器递增后，仍然可以通过解除保存的迭代器引用，来获得同样的值。另外，前向迭代器既可以是读写型的，也可以是只读的。


　　l 双向迭代器（bidirectional iterator）--可以用++和--操作符来双向遍历容器。其他与前向迭代器一样，也支持解除引用、也是多通的、也是可读写或只读的。


　　l 随机访问迭代器（random access iterator）--可直接访问容器中的任意一个元素的双向迭代器。


　　可见，这5种迭代器形成了一个层次结构：I/O迭代器（都可++遍历，但是前者只读/后者只写）最基本、前向迭代器可读写但只能++遍历、双向迭代器也可读写但能++/--双向遍历、随机迭代器除了能够双向遍历外还能够随机访问。


　　（3）指针与迭代器


　　既然迭代器是广义的指针，那么指针本身是不是迭代器呢？其实，指针满足所有迭代器的要求，所以，指针就是一种迭代器。


　　迭代器是泛型算法的接口，而指针是迭代器。所以，各种STL算法，也可以使用指针，来对非标准容器（如数组）进行操作。即，利用指针做迭代器，可以将STL算法用于常规数组。


　　例如排序函数sort:


　　sort（Ran first, Ran last）； // Ran表示随机访问迭代器


　　对容器c为：


　　sort（c.begin（）， c.end（））；


　　对数组a可以改为：（const int SIZE = 100; float a[SIZE];）


　　sort（a, a + SIZE）；


　　又例如复制函数copy:


　　copy（In first, In last, Out res）； // In和Out分别表示输入和输出迭代器


　　对容器c可为：（ostream_iterator out_iter（cout）；）


　　copy（c.begin（）， c.end（）， out_iter）；


　　对数组a可以改为：（const int SIZE = 100; float a[SIZE];）


　　copy（a, a + SIZE, c.begin（））；

--------------------------------------------------------------------------------------------------------------------

题目： 删除map<int, int>中value为5的倍数的元素。 该题看起来很自然很简单， 实则有迭代器失效的陷阱。

如果对迭代器失效问题一无所知， 则很容易写出如下的错误代码：

 

 1 #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++, 自然而然会出问题啊。 那怎么办呢？ 且看：

 

  1 #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 56  57   58  59   60  61        当然， 上述程序也可以继续简化为： 62  63   64  65 #include <iostream> 66 #include <map> 67 using namespace std; 68  69 typedef map<int, int> Map; 70 typedef map<int, int>::iterator MapIt; 71  72 void print(Map &m) 73 { 74     MapIt it; 75     for(it = m.begin(); it != m.end(); it++) 76     { 77         cout << it->second << " "; 78     } 79  80     cout << endl; 81 } 82  83 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 } 98  99 int main()100 {101     Map m;102     int i = 0;103     for(i = 0; i < 21; i++)104     {105         m[i] = i;106     }107 108     print(m);109 110     deleteValueFromMap(m); // 程序ok111     print(m);112 113     return 0;114 }115        结果ok.

      有的朋友肯定会问， m.erase(it++);就不会产生迭代器失效么？ 确实不会！ 为什么呢？ 这样从it++说起， 为了简便起见， 我们用p++来代替吧。 看程序：

 1 #include <iostream> 2 using namespace std; 3  4 int main() 5 { 6     char szTest[] = "abcdefg"; 7     char *p = szTest; 8  9     cout << *p++ << endl;10 11     return 0;12 }

 

       大家都知道， 结果为a.  但是， 很多人错误地以为是先执行*p, 然后执行p++, 其实， 这是个天大的误解。 大家可以查一下*和++的执行顺序， 虽然*和++的优先级相同， 但此处采取的是右结合方式， 实际上先执行的是p++, 不过， p++的返回值是原来的p, 也就是说, *p++的值还是a. 

       所以， 在m.erase(it++);中，it++先执行， 此时还没有erase， 程序自然不会崩溃. 当it++执行完后， 已经指向了下一个元素了， 但it++的返回值还是当前元素， 此时再删除它， 合情合理。

        OK,  map的迭代器失效问题，先介绍到这里。

        那vector又是怎样的现象呢？ 看程序：

 

  1 #include <iostream>  2 #include <vector>  3 using namespace std;  4   5 typedef vector<int> Vec;  6 typedef vector<int>::iterator VecIt;  7   8 void print(Vec &v)  9 { 10     VecIt it; 11     for(it = v.begin(); it != v.end(); it++) 12     { 13         cout << *it << " "; 14     } 15  16     cout << endl; 17 } 18  19 void deleteValueFromVector(Vec &v, int n = 5) 20 { 21     VecIt it; 22     for(it = v.begin(); it != v.end(); it++) 23     { 24         if(0 == *it % n) 25         { 26             v.erase(it); 27         } 28     } 29 } 30  31 int main() 32 { 33     Vec v; 34     int i = 0; 35     for(i = 0; i < 21; i++) 36     { 37         v.push_back(i); // 不能再傻傻地用下标了 38     } 39  40     print(v); 41  42     deleteValueFromVector(v); // 程序崩溃 43     print(v); 44  45     return 0; 46 } 47        运行程序， 结果程序也崩溃， 可见， vector也存在迭代器失效的问题， 怎么改呢？ 如下： 48  49   50  51   52  53 #include <iostream> 54 #include <vector> 55 using namespace std; 56  57 typedef vector<int> Vec; 58 typedef vector<int>::iterator VecIt; 59  60 void print(Vec &v) 61 { 62     VecIt it; 63     for(it = v.begin(); it != v.end(); it++) 64     { 65         cout << *it << " "; 66     } 67  68     cout << endl; 69 } 70  71 void deleteValueFromVector(Vec &v, int n = 5) 72 { 73     VecIt it; 74     for(it = v.begin(); it != v.end(); /*不能再自增了*/) 75     { 76         if(0 == *it % n) 77         { 78             v.erase(it); // vector元素自动向前挪动了(关联的map容器元素不会自动挪动)， 所以不能再把it进行++了 79         } 80         else 81         { 82             it++; 83         } 84     } 85 } 86  87 int main() 88 { 89     Vec v; 90     int i = 0; 91     for(i = 0; i < 21; i++) 92     { 93         v.push_back(i); // 不能再傻傻地用下标了 94     } 95  96     print(v); 97  98     deleteValueFromVector(v); // 程序ok 99     print(v);100 101     return 0;102 }103         结果为：104 105  106 107 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20108 1 2 3 4 6 7 8 9 11 12 13 14 16 17 18 19109 110         可见， vector迭代器失效的问题也不容忽视。