迭代器

《一》迭代器(iterator)有时又称游标(cursor)是程序设计的软件设计模式，可在容器(container，例如链表或阵列)上遍访的接口，设计人员无需关心容器的内容。

迭代器的分类：

1.输入迭代器(input iterator)功能

1. 取出其所指向的值  
2. 访问下一个元素
3. 判断是否到达了最后一个元素
4. 可以复制

因此其支持的操作符有  *p,++p,p++,p!=q,p == q这五个.凡是支持这五个操作的类都可以称作是输入迭代器.当然指针是符合的.

2.输出迭代器(output iterator)

 output iterator工作方式类似输出流,我们能对其指向的序列进行写操作,其与input iterator不相同的就是*p所返回的值允许修改,而不一定要读取,而input只允许读取,不允许修改.

支持的操作和上头一样,支持的操作符也是 *p,++p,p++,p!=q,p == q.

3.前向迭代器(forward iterator)

前向迭代器就像是输入和输出迭代器的结合体,其*p既可以访问元素,也可以修改元素.因此支持的操作也是相同的.

4.双向迭代器(bidirectional iterator)

双向迭代器在前向迭代器上更近一步,其要求该种迭代器支持operator--,因此其支持的操作有  *p,++p,p++,p!=q,p == q,--p,p--

5. 随机存取迭代器(random access iterator)

即如其名字所显示的一样,其在双向迭代器的功能上,允许随机访问序列的任意值.显然,指针就是这样的一个迭代器.

对于随机存取迭代器来说, 其要求高了很多:

1. 可以判断是否到结尾(  a==b or a != b)
2. 可以双向递增或递减( --a or ++a)
3. 可以比较大小( a < b or a > b or a>=b ...etc)
4. 支持算术运算( a + n)
5. 支持随机访问( a[n] )
6. 支持复合运算( a+= n)

《二》迭代器失效

迭代器失效并不是begin和end失效而是迭代器迭代元素失效

在STL里，我们不能以指针来看待迭代器，指针是与内存绑定的，而迭代器是与容器里的元素绑定的，删除了之后，该迭代器就失效了，在对其重新赋值之前，不能再访问此迭代器。

（1）增加元素到容器后

1. 对于vector和string，如果容器内存被重新分配，iterators,pointers,references失效；如果没有重新分配，那么插入点之前的iterator有效，插入点之后的iterator失效；
2. 对于deque，如果插入点位于除front和back的其它位置，iterators,pointers,references失效；当我们插入元素到front和back时，deque的迭代器失效，但reference和pointers有效；
3. 对于list和forward_list，所有的iterator,pointer和refercnce有效。

（2）从容器中移除元素后

1. 对于vector和string，插入点之前的iterators,pointers,references有效；off-the-end迭代器总是失效的；
2. 对于deque，如果插入点位于除front和back的其它位置，iterators,pointers,references失效；当我们插入元素到front和back时，off-the-end失效，其他的iterators,pointers,references有效；
3. 对于list和forward_list，所有的iterator,pointer和refercnce有效。

（3）在循环中refresh迭代器

当处理vector,string,deque时，当在一个循环中可能增加或移除元素时，要考虑到迭代器可能会失效的问题。我们一定要refresh迭代器。

int arr[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
    deque<int> v(arr,arr+sizeof(arr)/sizeof(*arr));
    for (auto it = v.begin(); it != v.end(); )
    {
        if ((*it) & 1)
        {
            it = v.insert(it, *it);
            it += 2;
        }
        else
            it = v.erase(it);
    }

至于it+=2，很容易解释，insert之后，it指向新增加的元素，+2之后，it指向下一个要处理的元素。

（4）在循环不变式中不要store off-the-end迭代器

这个很容易理解了，增加或移除元素之后，off-the-end失效了，不store的话，每次从end()函数中取的都是最新的off-the-end，自然不会失效。

《三》用例：迭代器失效

void main()
{
    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++，已经指向的是未知内存）。

但是erase方法可以返回下一个有效的iterator。所以代码做如下修改，就OK了

void main()
{
    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();)
    {
            if (*iter > 3) {
				iter = container.erase(iter);
			}
			else {
				iter ++;
			}
 
    }
 
     for (iter = container.begin(); iter != container.end(); iter++)
    {
            cout<<*iter<<endl;
    }
}

运行结果：

总结：vector是一个顺序容器，在内存中是一块连续的内存，当删除一个元素后，内存中的数据会发生移动，以保证数据的紧凑。所以删除一个数据后，其他数据的地址发生了变化，之前获取的迭代器根据原有的信息就访问不到正确的数据。

所以为了防止vector迭代器失效，常用如下方法：

for (iter = container.begin(); iter != container.end(); )
    {
            if (*iter > 3)
              iter = container.erase(iter);    //erase的返回值是删除元素下一个元素的迭代器
            else{
                iter++;
            }
    }

 

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

总结：迭代器失效分三种情况考虑，也是非三种数据结构考虑，分别为数组型，链表型，树型数据结构。

数组型数据结构：该数据结构的元素是分配在连续的内存中，insert和erase操作，都会使得删除点和插入点之后的元素挪位置，所以，插入点和删除掉之后的迭代器全部失效，也就是说insert(*iter)(或erase(*iter))，然后在iter++，是没有意义的。解决方法：erase(*iter)的返回值是下一个有效迭代器的值。 iter =cont.erase(iter);

链表型数据结构：对于list型的数据结构，使用了不连续分配的内存，删除运算使指向删除位置的迭代器失效，但是不会失效其他迭代器.解决办法两种，erase(*iter)会返回下一个有效迭代器的值，或者erase(iter++).

树形数据结构： 使用红黑树来存储数据，插入不会使得任何迭代器失效；删除运算使指向删除位置的迭代器失效，但是不会失效其他迭代器.erase迭代器只是被删元素的迭代器失效，但是返回值为void，所以要采用erase(iter++)的方式删除迭代器。