C++ STL迭代器失效情况总结

本文转自：https://www.cnblogs.com/Commence/p/7526421.html

1.对于序列式容器：vector，queue（C++的序列式容器有vector、deque、list、forward_list、array和string几种）等，序列式容器就是数组式容器，删除当前的iterator会使得后边所有元素的iterator都失效。这是因为其使用了连续分配的内存，阐述一个元素导致后面所有的元素都会向前移动一个位置，所以不能使用erase(iter++)的方式。但是erase方法可以返回下一个有效的iterator

for (iter = cont.begin(); iter != cont.end();)  
{  
   (*it)->doSomething();  
   if (shouldDelete(*iter))  
      iter = cont.erase(iter);  //erase删除元素，返回下一个迭代器  
   else  
      ++iter;  
}

 

迭代器失效的情况：（错误的）

void vectorTest()  
{  
    vector<int> container;  
    for (int i = 0; i < 10; i++)  
    {  
        container.push_back(i);  
    }  
  
    vector<int>::iterator iter;  
     for (iter = container.begin(); iter != container.end(); iter++)  
    {  
            if (*iter > 3)  
              container.erase(iter);  
    }  
  
     for (iter = container.begin(); iter != container.end(); iter++)  
    {  
            cout<<*iter<<endl;  
    }  
}

这段代码在删除后对迭代器自增，实际其本身已经失效了。　　对于vector，删除当前的iterator会使得用棉所有元素的iterator都失效，因为序列式容器内存是连续分配的，删除一个元素导致后面所有的元素都会向前移动一个位置。

所以此时iter++指向的未知位置。正确的做法是向前面一样的处理。

vector迭代器的几种失效的情况：（对于插入操作，只有vector才可能失效）

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

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

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

 

对于关联式容器如（map,set,multimap,multiset）,删除当前的iterator，仅仅会使当前的iterator失效，只要在erase时，递增当前iterator即可。这是因为map之类的容器，使用了红黑树来实现，插入、删除一个节点不会对其他节点造成影响，erase迭代器只是被删元素的迭代器失效，但是返回值为void，所以要采用erase(iter++)的方式删除迭代器。

 

void mapTest()  
{  
    map<int, string> dataMap;  
  
  
    for (int i = 0; i < 100; i++)  
    {  
           string strValue = "Hello, World";  
  
            stringstream ss;  
            ss<<i;  
            string tmpStrCount;  
            ss>>tmpStrCount;  
            strValue += tmpStrCount;  
            dataMap.insert(make_pair(i, strValue));  
    }  
  
    cout<<"MAP元素内容为："<<endl;  
     map<int, string>::iterator iter;  
    for (iter = dataMap.begin(); iter != dataMap.end(); iter++)  
    {  
            int nKey = iter->first;  
            string strValue = iter->second;  
            cout<<strValue<<endl;  
    }  
  
    cout<<"内容开始删除："<<endl;  
    /擦除操作引发迭代器失效  
    for (iter = dataMap.begin(); iter != dataMap.end();iter++)  
    {  
            int nKey = iter->first;  
            string strValue = iter->second;  
  
           if (nKey % 2 == 0)  
           {  
                dataMap.erase(iter);  
  
           }  
           /* cout<<iter->second<<endl;*/  
    }  
}

上述代码会出现问题：dataMap.erase(iter)之后，iterator就已经失效了，所以iter无法自增，解决的办法就是在其失效之前完成自增。

做出如下修改：

for (iter = dataMap.begin(); iter != dataMap.end();)  
    {  
            int nKey = iter->first;  
            string strValue = iter->second;  
  
           if (nKey % 2 == 0)  
           {  
                dataMap.erase(iter++);  
                auto a = iter;  
  
           }  
           else {  
               iter ++;  
           }  
    }

 

解析：dataMap.erase(iter++);这句话分几步走，先把iter传到erase里面，然后iter自增，然后再erase，所以iter在失效前已经自增了。

map是关联式容器，以红黑树或者平衡二叉树组织数据，虽然删除了一个元素，整棵树也会调整，以符合二叉树或者红黑树的规范，但是单个节点的改变必然会调整树的结构，其中单个节点在内存中的地址没有变化且各个节点的指向关系。另外一种保险和比较易读的写法是写一个临时迭代器保存当前迭代器，之后迭代器本身自增，在erase临时的

代码如下：

if (nKey % 2 == 0)  
         {  
               map<int, string>::iterator tmpIter = iter;  
           iter++;  
               dataMap.erase(tmpIter);  
               //dataMap.erase(iter++) 这样也行  
  
         }

总结：迭代器的失效分三种情况，分为数组形，链表性，树形数据结构

数组形数据结构：该数据结构元素是分配在连续的内存中。

链表性数据结构：其也是用了不连续分配的内存

树形数据结构：插入不会使得任何迭代器失效。