STL set的使用 vector List set map 成员函数erase

STL中的容器按存储方式分为两类，一类是按以数组形式存储的容器（如：vector 、deque)；另一类是以不连续的节点形式存储的容器（如：list、set、map）。在使用erase方法来删除元素时，需要注意一些问题。
      在使用 list、set 或 map遍历删除某些元素时可以这样使用：

正确使用方法1

      std::list< int> List;
      std::list< int>::iterator itList;
      for( itList = List.begin(); itList != List.end(); )
      {
            if( WillDelete( *itList) )
            {
               itList = List.erase( itList);
            }
            else
               itList++;
      }

       或

正确使用方法2

      std::list< int> List;
      std::list< int>::iterator itList;
      for( itList = List.begin(); itList != List.end(); )
      {
            if( WillDelete( *itList) )
            {
               List.erase(  itList++ );
            }
            else
               itList++;
      }

      
      下面是两个错误的使用方法：

错误使用方法1

      std::list< int> List;
      std::list< int>::iterator itList;
      for( itList = List.begin(); itList != List.end(); itList++)
      {
            if( WillDelete( *itList) )
            {
               List.erase( itList);
            }
      }

         或

错误使用方法2

      std::list< int> List;
      std::list< int>::iterator itList;
      for( itList = List.begin(); itList != List.end(); )
      {
            if( WillDelete( *itList) )
            {
               itList = List.erase( ++itList);
            }
            else
               itList++;
      }

      正确使用方法1：通过erase方法的返回值来获取下一个元素的位置
      正确使用方法2：在调用erase方法之前先使用 “++”来获取下一个元素的位置
      错误使用方法1：在调用erase方法之后使用“++”来获取下一个元素的位置，由于在调用erase方法以后，该元素的位置已经被删除，如果在根据这个旧的位置来获取下一个位置，则会出现异常。
      错误使用方法2：同上。

      这里“++”运算符与我们平常的理解刚好相反，erase( itList++) 是先获取下一个元素的位置在删除； erase( ++itList) 是删除以后再获取下一个元素的位置。 

     在使用 vector、deque遍历删除元素时，也可以通过erase的返回值来获取下一个元素的位置：

正确使用方法

      std::vector< int> Vec;
      std::vector< int>::iterator itVec;
      for( itVec = Vec.begin(); itVec != Vec.end(); )
      {
            if( WillDelete( *itVec) )
            {
                 itVec = Vec.erase( itVec);
            }
            else
               itList++;

   }

注意vector, list, set, map成员函数erase

1. #include <iostream>  
2. #include <vector>  
3. #include <list>  
4. #include <iterator>  
5. using namespace std;  
6.   
7. void Remove1(vector<int> &vec, int num)  
8. {  
9.     vector<int>::iterator iter;  
10.     for (iter=vec.begin(); iter!=vec.end(); ++iter)  
11.     {  
12.         if (*iter == num)  
13.         {  
14.             vec.erase(iter);  
15.         }  
16.     }  
17. }  
18.   
19. void Remove2(list<int> &lst, int num)  
20. {  
21.     list<int>::iterator iter;  
22.     for (iter=lst.begin(); iter!=lst.end(); ++iter)  
23.     {  
24.         if (*iter == num)  
25.         {  
26.             lst.erase(iter);  
27.         }  
28.     }  
29. }  
30.   
31. int main(void)  
32. {  
33.     int arr[] = {1, 3, 5, 5, 7, 9};  
34.     int num = sizeof(arr) / sizeof(arr[0]);  
35.     vector<int> vec(arr, arr+num);  
36.     list<int> lst(arr, arr+num);  
37.   
38.     Remove1(vec, 5);  
39.     copy(vec.begin(), vec.end(), ostream_iterator<int>(cout, " "));  
40.       
41.     //Remove2(lst, 5);  
42.     //copy(lst.begin(), lst.end(), ostream_iterator<int>(cout, " "));  
43.   
44.     return 0;  
45. }  

请看上面的Remove1、Remove2这两个函数是删除容器中所有为num的元素， 乍一看好像没什么问题， 其实是错的。

它们编译都没什么问题，但是运行有问题：
先注释Remove2这两行， 编译运行， 得到结果是：1 3 5 7 9
显然结果是错误的，因为还有个5没删掉。造成这样结果的原因是vec.erase之后iter会自加，执行下次for循环时++iter，这样就跳过了与所删除元素相邻的元素了。

再来看下Remove2， 注释掉Remove1， 删除Remove2的注释。
运行出错，vs2005 Expression:list iterator not incrementable，说明list迭代器++iter有问题。
list是一个双向链表，在erase(iter)之后iter失效了，printf("0x%x", iter);得到结果为0，只有erase的返回值才能指向下一个元素。

Remove1的正确用法是：vec.erase(remove(vec.begin(), vec.end(), 5), vec.end());
Remove2的正确用法是：lst.remove(5);

下面是另一种正确写法：

[cpp]  view plain copy

1. void Remove1(std::vector<int> &vec, int num)  
2. {  
3.     std::vector<int>::iterator iter = vec.begin();  
4.     while (iter != vec.end())  
5.     {  
6.         if (*iter == num)  
7.         {  
8.             iter = vec.erase(iter);  
9.         }  
10.         else  
11.         {  
12.             ++iter;  
13.         }  
14.     }  
15. }  
16.   
17. // 删除某一类元素， 比如：偶数  
18. void Remove3(std::set<int>& sets)  
19. {  
20.     std::set<int>::iterator iter = sets.begin();  
21.     while (iter != sets.end())  
22.     {  
23.         if (0 == (*iter)%2)  
24.         {  
25.             // 注意这里不能写成++iter，后面说明原因  
26.             sets.erase(iter++);  
27.         }  
28.         else  
29.         {  
30.             ++iter;  
31.         }  
32.     }  
33. }  
34.   
35. void Remove4(std::map<int, int>& maps)  
36. {  
37.     std::map<int, int>::iterator iter = maps.begin();  
38.     while (iter != maps.end())  
39.     {  
40.         if (0 == (iter->first)%2)  
41.         {  
42.             maps.erase(iter++);  
43.         }  
44.         else  
45.         {  
46.             ++iter;  
47.         }  
48.     }  
49. }  

set和map是由红黑树来实现的，当erase的时候迭代器就失效了，也就是说我们要在迭代器失效之前
保留一个副本，根据这个副本我们才能继续遍历下一个元素。i++和++i很明显前者符合我们的要求所以
在erase里面是iter++