万叶集
🎉 隐约雷鸣，阴霾天空。 🎉
🎉 但盼风雨来，能留你在此。 🎉

---

前言：
✌ 作者简介：渴望力量的哈士奇 ✌，大家可以叫我 🐶哈士奇🐶 ，一位致力于 TFS 赋能的博主 ✌
🏆 CSDN博客专家认证、新星计划第三季全栈赛道 top_1 、华为云享专家、阿里云专家博主 🏆
📫 如果文章知识点有错误的地方，请指正！和大家一起学习，一起进步👀
💬 人生格言：优于别人,并不高贵,真正的高贵应该是优于过去的自己。💬
🔥 如果感觉博主的文章还不错的话，还请👍关注、点赞、收藏三连支持👍一下博主哦

---

专栏系列（点击解锁）	学习路线指引	知识定位
🔥Python全栈白皮书🔥	零基础入门篇	以浅显易懂的方式轻松入门，让你彻底爱上Python的魅力。
	语法进阶篇	主要围绕多线程编程、正则表达式学习、含贴近实战的项目练习 。
	自动化办公篇	实现日常办公软件的自动化操作，节省时间、提高办公效率。
	自动化测试实战篇	从实战的角度出发，先人一步，快速转型测试开发工程师。
	数据库开发实战篇	更新中
	爬虫入门与实战	更新中
	数据分析篇	更新中
	前端入门+flask 全栈篇	更新中
	django+vue全栈篇	更新中
	拓展-人工智能入门	更新中
网络安全之路	踩坑篇	记录学习及演练过程中遇到的坑，便于后来居上者
	网安知识扫盲篇	三天打鱼，不深入了解原理，只会让你成为脚本小子。
	vulhub靶场漏洞复现	让漏洞复现变得简单，让安全研究者更加专注于漏洞原理本身。
	shell编程篇	不涉及linux基础，最终案例会偏向于安全加固方向。 [待完结]
	WEB漏洞攻防篇	2021年9月3日停止更新，转战先知社区等安全社区及小密圈
	渗透工具使用集锦	2021年9月3日停止更新，转战先知社区等安全社区及小密圈
点点点工程师	测试神器 - Charles	软件测试数据包抓包分析神器
	测试神器 - Fiddler	一文学会 fiddle ，学不会倒立吃翔，稀得！
	测试神器 - Jmeter	不仅是性能测试神器，更可用于搭建轻量级接口自动化测试框架。
	RobotFrameWork	Python实现的自动化测试利器，该篇章仅介绍UI自动化部分。
	Java实现UI自动化	文档写于2016年，Java实现的UI自动化，仍有借鉴意义。
	MonkeyRunner	该工具目前的应用场景已不多，文档已删，为了排版好看才留着。

---

---

什么是迭代器

迭代是 python 中访问集合元素的一种非常强大的一种方式。迭代器是一个可以记住遍历位置的对象，因此不会像列表那样一次性全部生成，而是可以等到用的时候才生成，因此节省了大量的内存资源。迭代器对象从集合中的第一个元素开始访问，直到所有的元素被访问完。迭代器有两个方法：iter()和 next()方法。

这么解释可能不太直观，我们以生活的一个小栗子来解释一下，方便大家能够更深刻的理解。比如说我们去超市买水果，而正巧超市的服务人员正在摆放苹果。服务人员告诉我们需要等苹果都摆放完毕我们才可以拿苹果，这样就很耽误我们的时间。(这个场景中，柜台上其实已经有苹果了，只不过销售不让拿罢了。)

然后我们再去卖橘子的柜台，服务人员也在摆放橘子。但是服务人员告诉我们可以不用等他摆放完毕，我们可以直接拿橘子，这样就会很好的节省我们的时间。如果我们拿橘子的速度超过了服务人员摆放的速度 ，我们只需要等待服务人员摆放之后就可以直接拿橘子，大大的提升了我们买橘子的效率。

而迭代器就类似于我们买橘子的场景，我们平时的程序都是一次性写入到内存中。比如我们的列表中存在成百上千的数据，都是一次性写入到内存里的，通过这样让我们来使用。但是迭代器却是按需加载，有一点内容就会放在内容里面，我们就可以立刻使用内存中的数据进行我们的逻辑处理。这样就不要所有的数据都写入到内存中就可以使用，大大的提升了使用效率。

如何生成迭代器

迭代器函数 - iter() 函数 与 next() 函数

    iter(iterable)从可迭代对象中返回一个迭代器,iterable必须是能提供一个迭代器的对象
    next(iterator) 从迭代器iterator中获取下一了记录,如果无法获取下一条记录,则触发stoptrerator异常
    说明:
        1.迭代器只能往前取值,不会后退
        2.用iter函数可以返回一个可迭代对象的迭代器
    示例:

iter()函数介绍：生成一个迭代器对象

iter()函数用法：iter(iterable)

参数介绍：iterable —> 可迭代的数据类型（比如列表、字典、元组以及集合类型等）

示例：iter([1, 2, 3])

返回值：<list_iterator at 0x4f3bff0>

---

next()函数介绍：返回迭代器中的数据

next()函数用法：next(iterable)

参数介绍：iterable —> 迭代器对象

示例：

iter_obj = iter([1,2,3])
next(iter_obj)

返回值：

# >>> 1,2,3
# >>> StopIteration

综上，我们得出结论：

iter(iterable)从可迭代对象中返回一个迭代器,iterable必须是能提供一个迭代器的对象
next(iterable) 从迭代器iterator中获取下一了记录,如果无法获取下一条记录,则触发stoptrerator异常

演示案例如下：

# coding:utf-8


test_list = [1, 3, 5, 7]
test_iter = iter(test_list)     # 让test_list提供一个能访问自己的迭代器
print(next(test_iter))     # 1  从迭代器中取值,让迭代器去获取l中的一个元素
print(next(test_iter))     # 3
print(next(test_iter))     # 5
print(next(test_iter))     # 7
print(next(test_iter))     # StopIterable 异常

---

test_list 实际上是一个列表，但是被迭代器迭代之后。并不是一次性将列表放入内存中，而是每次放一个元素进入内存，然后被读取。(这就是我们说的按需加载)

---

可迭代的对象

类似于list、tuple、str 等类型的数据可以使用for… in… 的循环遍历语法可以从其中依次拿到数据并进行使用，我们把这个过程称为遍历，也称迭代。python中可迭代的对象有list（列表）、tuple（元组）、dirt（字典）、str（字符串）set(集合)等。

示例如下：

test_list = [1,2,3,4,5]
test_dirt = {
    "name":"张三",
    "sex":"男",
    "age":33
    }
    
test_tuple = (1,2,3,4,5)
test_set = {1,2,3,3,4}
 
    
for i in test_list:
    print(i)
 
for i in test_dirt:
    print(i)
 
for i in test_tuple:
    print(i)
 
for i,j in test_set.items():
    print("%s:%s" % (i,j))
    
# >>> 执行结果如下：
# >>> test_list的元素为： 1
# >>> test_list的元素为： 2
# >>> test_list的元素为： 3
# >>> test_list的元素为： 4
# >>> test_list的元素为： 5
# >>> test_dirt的元素为： name
# >>> test_dirt的元素为： sex
# >>> test_dirt的元素为： age
# >>> test_tuple的元素为： 1
# >>> test_tuple的元素为： 2
# >>> test_tuple的元素为： 3
# >>> test_tuple的元素为： 4
# >>> test_tuple的元素为： 5
# >>> test_set的元素为：1
# >>> test_set的元素为：2
# >>> test_set的元素为：3
# >>> test_set的元素为：4

生成迭代器

除了刚刚我们使用的 iter() 函数之外 ，我们还有其他方法生成迭代器：

第一种：for循环生成方法 —> 我们可以在函数中使用 for 循环， 并对每一个 for 循环的成员使用 yield() 函数 [它的意思就是将每一个 for 循环成员放到一个迭代器对象中，不过只有被调用才会被放入。]

示例如下：

def test():
    for i in range(10):
        yield i


result = test()

print('for 循环，第一次 \'i\'的值为：', next(result))
print('for 循环，第二次 \'i\'的值为：', next(result))
print('for 循环，第三次 \'i\'的值为：', next(result))
print('for 循环，第四次 \'i\'的值为：', next(result))

# >>> 执行结果如下：
# >>> for 循环，第一次 'i'的值为： 0
# >>> for 循环，第二次 'i'的值为： 1
# >>> for 循环，第三次 'i'的值为： 2
# >>> for 循环，第四次 'i'的值为： 3

注意:超过10次异常会抛 StopIteration 的异常。

---

第二种：for 循环一行生成迭代器对象。

示例如下：

result = (i for i in [1, 2, 3])		# 将 for 循环在非函数中 赋值 给一个变量， 这也是生成一个迭代器变量的方法  

print('for 循环，第一次 \'i\'的值为：', next(result))		# 使用 next 调用迭代器
print('for 循环，第二次 \'i\'的值为：', next(result))
print('for 循环，第三次 \'i\'的值为：', next(result))

# >>> for 循环，第一次 'i'的值为： 1
# >>> for 循环，第二次 'i'的值为： 2
# >>> for 循环，第三次 'i'的值为： 3

注意: next(result) 超过4次会抛 StopIteration 的异常。

划重点：

使用 for 循环生成的迭代器，可以不使用 next() 函数 也可以执行，（依然可以通过 for 循环 获取迭代器的数据）不仅如此，当我们调取完迭代器中的数据之后，程序不会抛出异常，相比较与 next() 函数要友好的多。

示例如下：

result = (i for i in [1, 2, 3])

for item in result:
    print(item)
    
# >>> 执行结果如下：
# >>> 1
# >>> 2
# >>> 3

# 循环结束，程序正常退出，不会抛出 StopIteration 的异常

---

迭代器的用法 - 演示案例

案例一：

def make_iter():
    for i in range(5):
        yield i

iter_obj = make_iter()

for i in iter_obj:
    print(i)
print('----')
for i in iter_obj:
    print(i)
    
# >>> 执行结果如下：
# >>> 0
# >>> 1
# >>> 2
# >>> 3
# >>> 4
# >>> ----

# >>> 从运行结果得出结论，当我们从内存中读取完迭代器所有的值后，内存就会被释放，不再循环输出。

案例二：

iter_obj = (i for i in range(4))

for i in iter_obj:
    print(i)
print('=====')
for i in iter_obj:
    print(i)

# >>> 执行结果如下：
# >>> 0
# >>> 1
# >>> 2
# >>> 3
# >>> =====
# >>> 从运行结果得出结论，当我们从内存中读取完迭代器所有的值后，内存就会被释放，不再循环输出。

迭代器 除了前文我们提到的 按需加载 ，可以提升我们的执行速度以外。

还有另外一个原因，试想一下：如果我们的列表只有10个数据，那么读取的速度会很快。可能对资源（也就是我们的内存）占用的消耗不是很大；如果我们有一个成千上万甚至十万数据的列表，那么这些数据都要一次性的写入内存里，这么多的数据所消耗占用的资源必然会很大，甚至会撑爆我们的内存造成内存溢出，程序就会报错了。

所以如果通过迭代器的方式，我们只需要用到一个数据就将一个数据扔到内存里并且被使用。这样既可以提高我们内存使用的效率，又可以减少我们内存的消耗。这也是我们平时使用迭代器的目的。

1、自C++11起可以用range-based for循环来所有元素，但有时并不需要处理所有元素，此时可以使用迭代器。

std::vector<int> vec {1,2,3,4,5,6,7,8,9,10};
for (auto n : vec){
    std::cout << n << endl;
}

2、迭代器中用来表现容器中的某个位置

• operator * :返回当前位置上的原始值。如果该元素拥有成员，可用-->取用他它们。
• operator  ++ :返回当前位置上的元素值，有些迭代器还可以使用operator ——退至前一元素。（注：“前置++”比“后置++”效率高）
• operator == 和 !=:判断两个迭代器是否指向同一位置。
• operator = ：对迭代器赋值。

3、容器的begin()和end()

begin()：返回一个迭代器，指向容器终点，即第一个元素（如果有的话）的位置。

end()：返回一个迭代器，指向容器终点。终点位于最末元素的下一位置，又称“逾尾迭代器”。

 

4、range-based for循环VS迭代器

对容器而言rang-based for循环不过是个便捷接口，用来迭代它“所接收到的几何区间”内每一个元素。在循环体内，真实元素被“当前迭代器所指向的value”初始化。

（1）range-based for循环

for (type  elem : coll){

...

}

（2）迭代器

for(auto pos = coll.begin(), end = coll.end(); pos != end; ++pos+){

type elem = *pos;

...

}

 

5、迭代器的种类

（1）前向迭代器(Forward iterator) 只能够以累加操作符(increment operator) 向前迭代。

Class forward _list的迭代器就属此类。其他容器如unordered_ set、 unordered_multiset、 unordered_map和unordered_multimap 也都至少是此类别(但标准库其实为它们]提供的是双向迭代器[forward iterator]。

（2）双向迭代器(Bidirectional iterator)顾 名思义它可以双向行进:以递增(increment)运算前进或以递减(decrement) 运算后退。list. set、 multiset、 map 和multimap提供的迭代器都属此类。

（3）随机访问迭代器(Random-access iterator)它 不但具备双向迭代器的所有属性，还具备随机访问能力。更明确地说，它们提供了迭代器算术运算的必要操作符(和寻常指针的算术运算完全对应)。你可以对迭代器增加或减少- - 个偏移量、计算两迭代器间的距离，或使用<和>之类的relational (相对关系)操作符进行比较。vector, deque.array和string提供的迭代器都属此类。除此之外，STL还定义了两个类别:

●输入型迭代器(Input iterator) 向前选代时能够读取/处理value。 Input stream迭代器就是这样-一个例子。

●输出型迭代器(Output iterator) 向前迭代时能够涂写value。 Inserter 和output stream迭代器都属此类。

 

6、具体迭代器

（1）output迭代器

a、output迭代器允许一步一步前行并搭配writ动作。

可以一个一个元素地赋值，但不能使用output迭代器对同一区间迭代两次。无比较操作，无法检验output迭代器是否有效，或写入是否成功。

b、output迭代器的操作

c、通常，迭代器可用来读，也可用来写，几乎所有reading迭代器都有write 的额外功能，这种情况下它们]被称为mutable (可产生变化的)迭代器。

      一个典型的pure output迭代器例子是:“将元素写至标准输出设备(例如屏幕或打印机)”。如果采用两个output迭代器写至屏幕，第二个字将跟在第一个字后面，而不是覆盖(overwrite)第一个字。另一个典型例子是inserter,那是一种用 来将value 插入(insert) 容器内的迭代器:如果你赋值(assign) 一个value,你其实是将它插入(insert) 容器。如果随后写入第二个value,并不会覆盖第一个 value,而是安插进去。

（2）input迭代器

a、input迭代器只能一次一个以前行方向读取元素，按此顺序一个一个返回元素值。

input迭代器只能读取元素。如果复制input迭代器，并令input迭代器和新产生的拷贝都前向读取，可能会有不同的值。

b、input迭代器的操作

c、所有迭代器都具备input迭代器的能力，而且往往更强。Pure input迭代器的典型例子就是“从标准输人设备(往往是键盘)读取数据”。同一个值不会被读取两次。一旦从input stream读人一个字(离开input缓冲区)，下次读取时就会返回另一一个字。

（3）forward（前向）迭代器

a、forward迭代器是一种input迭代器且在前进读取时提供额外保证。

b、forward迭代器的操作

（4）bidirectional（双向）迭代器

a、bidirectional迭代器是在 forward迭代器的基础上增加了回头迭代器能力。

b、bidirectional迭代器新增操作

c、bidirectional迭代器由一下对象和类型提供：

• Class list<>
• Associative (关联式)容器。

如果bidirectional迭代器履行了output迭代器立有的条件，那么它就是个mutable bidirectional迭代器，既可用于读取，也可用于涂写。

（5）Random-Access（随机访问）迭代器

a、random-access迭代器是在bidirectional迭代器的基础上增加了随机访问的能力。因此它能提供iterator算术运算，即它能增减某个偏移量、计算距离，并运诸如<和>等关系操作符进行比较。

b、random-access迭代器的新增的操作

d、random-access迭代器提供者：

• 可随机访问的容器（array、vector、deque）
• String（string、wstrin）
• 寻常的C-style array（pointer）

注：在使用的时候注意迭代器指向的位置，特别是一些特殊的位置，比如begin()前面，或者end()后面则会产生越界。

 

7、迭代器相关辅助函数

（1）advance()

a、advance()课件迭代器的位置增加，增加幅度由实参决定，即它令迭代器一次前景（或后退）多个元素。

b、#include<iterator>

void advance (InputIterator& pos, Dist n)

 ●令名称为pos的 input迭代器前进(或后退) n个元素。

 ●对bidirectional迭代器和random-access迭代器而言，n可为负值，表示向后退。

●Dist是个 template类型。通常它必须是个整数类型，因为会调用诸如<. ++. -- 等操作，还要和0做比较。

●advance() 并不检查迭代器是否超过序列的end() (因为迭代器通常不知道其所操作的容器，因此无从检查)。所以，调用advance()有可能导致不明确行为--因为 “对序列尾端调用operator++"是一种未被定义的行为。

（2）next()和prev()

a、用于前进和后退移动迭代器的位置

b、next()

#include<iterator>

ForwardIterator next(ForwardIterator pos)

ForwardIterator next(ForwardIterator pos, Dist n)

●导致 forward迭代器pos前进1或n个位置。

●如果 处理的是bidirectional和random-access迭代器，n可为负值，导致后退(回头)移 动。

●Dist是类型std: :iterator _traits<ForwardIterator>: :difference. type。●其内部将对一个临时 对象调用advance (pos,n)。

●注意，next()并不检查是否会跨越序列的end()。 因此调用者必须自行担保其结果有效。

c、prev()

BidirectionalIterator prev(BidirectionalIterator pos)

BidirectionalIterator prev(BidirectionalIterator pos, Dist n)

●导致 bidrctional迭代器pos后退1或n个位置。

●n可为负值，导致向前移动。

●Dist是类型std::iterator. traits<BidirectionalIterator>: :difference_type。

●其内部将对一个临时对象调用advance(pos, -n)。

●注意，prev()并不检查是否会跨越序列的begin()。因此调用者必须自行担保其结果有效。注：next()和prev()始自C++11，因此若以operator++和--取而代之，有可能无法针对每一种容器都通过编译。

（3）distance()

a、distance()用来处理两个迭代器之间的距离

b、#include<iterator>

Dist distance (InputIterator pos1, InputIterator pos2)

●返回两个input迭代器posI和pos2之间的距离。

●两个迭代器必须指向同一个容器。

●如果不是random-access迭代器，则从pos1开始前进必须能够到达pos2， 亦即pos2的位置必须与posl相同或在其后。

●返回类型Dist是迭 代器相应的difference类型:

iterator_ traits<InputIterator>: :difference_ type

（4）iter_swap()

a、iter_swap()这个辅助函数用来交换两个迭代器所指的元素值

b、#include<algorithm>

void iter_swap(ForwardIterator1 pos1, ForwardIterator2 pos2 )

• 交换迭代器pos1和pos2所指的值
• 迭代器的类型不必相同，但其所指的两个值必须可以互相赋值

 

8、迭代器适配器

（1）反向迭代器

反向处理元素

例：

void print(int elem) {
	cout << elem << ' ';
}

int main()
{
	list<int> coll = { 1, 2, 3, 4, 5 };
	for_each(coll.begin(), coll.end(), print);
	cout << endl;

	for_each(coll.rbegin(), coll.rend(), print);
	cout << endl;
	

	system("pause");
	return 0;
}

输出：

注：rebegin()：逻辑位置是从最后一个位置的后一个位置起算的，但其物理位置为他的前面一位。

rend():指针逻辑位置为第一位，物理位置为第一位的前面一位（有时候并不存在）。

注：foreach()

函数原型：

template<typename InputIterator, typename Function>
Function for_each(InputIterator beg, InputIterator end, Function f) {
    while(beg != end) 
    f(*beg++);
}

b、迭代器和反向迭代器

反向迭代器的逻辑位置和物理位置的值不一样。

（图1）反向迭代器的位置和其value（其所指元素值）的关系

（图2）迭代器pos和reverse（反向）迭代器rpos直接的转换

注：

reverse 迭代器的设计者运用了一个小技巧:他们实际倒置了“半开原则”。Reverse迭代器听定义的区间，并不包括起点，反倒是包括了终点。然而逻辑上其行为一如往常。这么一来reverse迭代器物理意义所指的元素位置，和逻辑意义所指的元素位置就不一致(如图1所示)。现在问题是，将一个迭代器转化为reverse迭代器，过程中发生了什么?该迭代器所保持(履行)的究竟是逻辑位置(value) 还是物理位置(element)? 从上面的例子可知，后者才是答案。因此，其value (也就是其所指元素值)也就移到了前一个元素身上(如图2所示)。

注：

以图2为例，当我们]把pos转换为rpos,它们指向同-一点，但它们所代表的意义(或说它们所代表的逻辑位置)不同了，*pos 为5，*rpos 则是4。换另一个角度看，如果你把[rbegin(), rend())形成的区间颠倒过来(把图上下颠倒看)，你会发现其性质就和以[begin(), end()形成的区间完全- 样。

例：

    vector<int> coll = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
	vector<int>::const_iterator pos;
	for_each(coll.begin(), coll.end(), print);
	cout << endl;
	pos = find(coll.begin(), coll.end(), 5);
	cout << &pos << " pos: " << *pos << endl;

	vector<int>::const_reverse_iterator rpos(pos);
	for_each(coll.rbegin(), coll.rend(), print);
	cout << endl;
	cout << &rpos << " rpos: " << *rpos << endl;

输出：

注：find():返回第一次找到元素的位置

例：

#include<iostream>
#include<deque>
#include<deque>
#include<algorithm>

using namespace std;

void print(int elem) {
	cout << elem << ' ';
}

int main()
{
	deque<int> coll = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
	deque<int>::const_iterator pos1;
	pos1 = find(coll.cbegin(), coll.cend(), 2);

	deque<int>::const_iterator pos2;
	pos2 = find(coll.cbegin(), coll.cend(), 7);

	for_each(pos1, pos2, print);
	cout << endl;

        // [pos1, pos2)
	deque<int>::const_reverse_iterator rpos1(pos1);
	deque<int>::const_reverse_iterator rpos2(pos2);

	for_each(pos1, pos2, print);
	cout << endl;

	system("pause");
	return 0;
}

输出：

c、运用base()将reserve迭代器转回正常

base()可以将reserve迭代器转回正常的迭代器

例：

vector<int> coll = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
vector<int>::const_iterator pos;
pos = find(coll.begin(), coll.end(), 5);
cout << "pos: " << *pos << endl;

vector<int>::const_reverse_iterator rpos(pos);
cout << "rpos: " << *rpos << endl;

vector<int>::const_iterator rrpos;
rrpos = rpos.base();
cout << "rrpos: " << *rrpos << endl;

（2）insert（安插型）迭代器

a、用来将“赋予新值”动作转换为“安插新值”动作。算法将执行安插行为而非覆写行为。

b、insert迭代器允许的操作

• operator *别实现为一个无作用的no-op，仅仅返回*this。所以对insert迭代器来说，*pos与pos等价。
• 赋值动作(assignment) 被转化为安插动作(insertion)。 事实上，insert 迭代器会调用容器的push. back()、push. .front()或insert()成员函数。

c、insert迭代器的中类

C++标准库提供三种insert迭代器: back inserter, front inserter和general inserter。它们之间的区别在于安插的位置。事实上，它们各自调用所属容器中不同的成员函数。所以insert迭代器初始化时- -定要清楚指明所属的容器是哪一种。

每一种insert迭代器都可以由一个对应的便捷函数加以生成和初始化。

注：容器本身要支持insert迭代器所调用的函数。back_insert只能用在vector、deque、list和string上，front_insert只能用在deque和list上。

例：back_insert_iterator

#include<iostream>
#include<iterator>
#include<vector>
#include<algorithm>

using namespace std;

void print(int elem) {
	cout << elem << ' ';
}

int main()
{
	vector<int> coll;
	back_insert_iterator<vector<int> > iter(coll);

	*iter = 1;
	iter++;
	*iter = 2;
	for_each(coll.begin(), coll.end(), print);
	cout << endl;

	back_inserter(coll) = 23;
	back_inserter(coll) = 65;
	for_each(coll.begin(), coll.end(), print);
	cout << endl;

	coll.reserve(2 * coll.size());	//注意在调用copy之前要保证有足够的空间
	copy(coll.begin(), coll.end(), back_inserter(coll));
	for_each(coll.begin(), coll.end(), print);
	cout << endl;

	system("pause");
	return 0;
}

输出：

注：general insert（insert_iterator）

根据两个实参完成初始化：容器；待安插的位置

general insert对所以容器适用（除array和forward list）

例：

#include<iostream>
#include<set>
#include<list>
#include<algorithm>
#include<iterator>

using namespace std;

void print(int elem) {
	cout << elem << ' ';
}

int main()
{
	set<int> coll;
	insert_iterator<set<int> > iter(coll, coll.begin());

	*iter = 1;
	iter++;
	*iter = 2;
	
	inserter(coll, coll.end()) = 66;
	inserter(coll, coll.end()) = 88;
	cout << "set: ";
	for_each(coll.begin(), coll.end(), print);
	cout << endl;

	list<int> coll2;
	copy(coll.begin(), coll.end(), inserter(coll2, coll2.begin()));
	cout << "list: ";
	for_each(coll2.begin(), coll2.end(), print);
	cout << endl;

	copy(coll.begin(), coll.end(), inserter(coll2, ++coll2.begin()));
	cout << "list: ";
	for_each(coll2.begin(), coll2.end(), print);
	cout << endl;

	system("pause");
	return 0;
}

输出：

 

（3）Stream（串流）迭代器

1）ofstream

Ostream迭代器可以将“被赋值”(assigned value)写人output stream.用了它，算法就可以直接写人stream.其实现机制与insert迭代器概念一致，唯一的区别在f ostream迭代器将赋值动作转化为output动作(通过operator<<)。 如此一来算法就可以使用寻常的选代器接口直接对stream执行涂写动作。

ostream 迭代器提供的各项操作：

例：

int main()
{
	ostream_iterator<int> intWriter(cout, "\n");

	*intWriter = 61;
	intWriter++;
	*intWriter = 88;

	vector<int> coll = { 1, 2, 3, 4, 5, 6 };
	copy(coll.begin(), coll.end(), ostream_iterator<int>(cout, "<"));
	cout << endl;

	return 0;
}

输出：

2）istream

从input stream读取元素，注意可能读取会失败（读取到文件尾部，或读取失败），终点位置可以使用end-of-stream，只要任何一次读取失败，所以istream迭代器都会变成end-of-stream迭代器，所以进行一次读取后，应该将istream迭代器拿来和end-of-stream迭代器做比较，看此迭代器是否还有效。

操作如下：

如果满足一下条件则说明两个istream迭代器相等：

• 两者都是end-of-stream迭代器（因而不能再进行读取）或
• 两者都可以再进行读取，并指向相同的stream

例：

int main()
{
	istream_iterator<int> intReader(cin);
	istream_iterator<int> intReaderEOF;

	while (intReader != intReaderEOF)
	{
		cout << "once:      " << *intReader << endl;
		cout << "once again:" << *intReader << endl;
		++ intReader;
	}
	return 0;
}

读取到f（类型不匹配）时退出

例：

int main()
{
	istream_iterator<int> cinPos(cin);
	ostream_iterator<int> coutPos(cout, "-->");

	while (cinPos != istream_iterator<int>())
	{
		advance(cinPos, 2);		//跳过输入单元
		if (cinPos != istream_iterator<int>())	//检查istream迭代器是否有效，防止越界
		{
			*coutPos++ = *cinPos++;
		}
	}
	cout << endl;
	return 0;
}

（4）move迭代器

以move迭代器取代copy，将元素从一个区间放到另一个区间。

例：

std::list<std::string> s;
	std::vector<string> v1(s.begin(), s.end());				// 把字符串s复制到v1
	std::vector<string> v2(make_move_iterator(s.begin()),		// 把字符串s移动到v2
		make_move_iterator(s.end()));

        一般而言，只有当“算法将元素从某个来源区间迁移(transfer) 至某个目标区间”，这种情况下在算法中使用move迭代器才有意义。此外，你必须确保每个元素只被处理- -次，否则，其内容将被搬移一次以上,那会导致不明确的行为。

      注意，唯一保证“元素只被读取或被处理-次”的迭代器种类是input iterator。因此，通常只有当“某算法有个来源端，其内要求input iterator. 并且有个目的端，其内使用output iterator”,这时候使用move迭代器才有意义。唯例外是for. each(),它可处理波指明区间(passed range)内的被搬移元素(moved element)，例如把它们搬移到一个新容器内。

一、advance

头文件iterator

template <class InputIterator, class Distance>
  void advance (InputIterator& it, Distance n);

推进迭代器
通过n个元素位置推进迭代器。

如果它是随机访问迭代器，则该函数仅使用一次operator +或operator-。 否则，该函数重复使用增加或减少运算符（运算符++或运算符 - ），直到n个元素被提前。

参数

1. it
   迭代器要先进。
   InputIterator至少应该是一个输入迭代器。
2. n
   要提前的元素位置数。
   这对随机访问和双向迭代器只是负面的。
   Distance应为能够表示此类迭代器之间距离的数值类型。

返回值

没有

// advance example
#include <iostream>     // std::cout
#include <iterator>     // std::advance
#include <list>         // std::list

int main () {
  std::list<int> mylist;
  for (int i=0; i<10; i++) mylist.push_back (i*10);

  std::list<int>::iterator it = mylist.begin();

  std::advance (it,5);

  std::cout << "The sixth element in mylist is: " << *it << '\n';

  return 0;
}

复杂度

随机访问迭代器的常量。
否则，线性为n。

迭代器有效性

推进一个至少不是前向迭代器的输入迭代器可能会使从其值获得的任何迭代器，指针和引用无效。

数据范围

该函数修改迭代器，但它永远不会被解引用（调用不会访问指向对象）。
还要注意上面描述的对迭代器有效性的影响。

异常

如果在迭代器上执行的任何算术运算抛出，则抛出，提供与此类操作相同的保证级别。

二、distance

template<class InputIterator>
  typename iterator_traits<InputIterator>::difference_type
    distance (InputIterator first, InputIterator last);

返回迭代器之间的距离
计算第一个和最后一个之间的元素数。

如果它是随机访问迭代器，则函数使用operator-来计算它。 否则，该函数重复使用增量运算符（operator ++）。

参数

1. first
   迭代器指向初始元素。
2. last
   迭代器指向最后的元素。 这必须从一开始就可以到达。

InputIterator至少应该是一个输入迭代器。

返回值

第一个和最后一个之间的元素数量。

// distance example
#include <iostream>     // std::cout
#include <iterator>     // std::distance
#include <list>         // std::list

int main () {
	std::list<int> mylist;
	for (int i=0; i<10; i++) mylist.push_back (i*10);

	std::list<int>::iterator first = mylist.begin();
	std::list<int>::iterator last = mylist.end();

	std::cout << "The distance is: " << std::distance(first,last) << '\n';

	return 0;
}

复杂度

随机访问迭代器的常量。
否则，线性为n。

迭代器有效性

如果InputIterator不是至少一个前向迭代器，那么首先和任何迭代器，从其值获得的指针和引用可能会失效。

数据范围

该函数访问两个迭代器，但没有解除引用（调用不访问指向对象）。
还要注意上面描述的对迭代器有效性的影响。

异常

如果在迭代器上执行的任何算术运算抛出，则抛出，提供与此类操作相同的保证级别。

三、begin

头文件iterator、array、deque、forward_list、list、map、regex、set、string、unordered_map、unordered_set、vector
【C++ 11】

container (1)	
template <class Container>
  auto begin (Container& cont) -> decltype (cont.begin());
template <class Container>
  auto begin (const Container& cont) -> decltype (cont.begin());
array (2)	
template <class T, size_t N>
  T* begin (T(&arr)[N]);

迭代开始
返回指向序列中第一个元素的迭代器：

（1）容器
该函数返回cont.begin()。
（2）数组
该函数返回其参数的数组到指针的转换。

如果序列为空，则不应取消引用返回的值。

这些函数模板在多个头文件中定义：这些头文件中的每一个都包含所有容器和数组类型的通用模板，而不仅仅是特定的重载。 头文件是：<iterator>，<array>，<deque>，<forward_list>，<list>，<map>，<regex>，<set>，<string>，<unordered_map>，<unordered_set>和<vector>。

相反，<initializer_list>和<valarray>中的begin被重载（具有不同的定义）。

参数

1. cont
   定义了成员begin的类类型的对象。
2. arr
   数组。

返回值

对于（1），与cont.begin（）返回的相同。
对于（2），指向数组中第一个元素的指针。

数据范围

访问该参数但未修改。
调用不会访问序列中的任何元素，但返回的迭代器可用于访问或修改它们。

异常

提供与对参数执行的操作相同级别的保证（对于标准容器和数组，这是一种无抛出保证）。

四、end

头文件iterator、array、deque、forward_list、list、map、regex、set、string、unordered_map、unordered_set、vector
【C++ 11】

container (1)	
template <class Container>
  auto end (Container& cont) -> decltype (cont.end());
template <class Container>
  auto end (const Container& cont) -> decltype (cont.end());
array (2)	
template <class T, size_t N>
  T* end (T(&arr)[N]);

迭代器结束
返回指向序列中的past-the-end元素的迭代器：

（1）容器
该函数返回cont.end（）。
（2）数组
该函数返回arr + N.

如果序列为空，则返回的值将与begin返回的值相等，并使用相同的参数。

这些函数模板在多个头文件中定义：这些头文件中的每一个都包含所有容器和数组类型的通用模板，而不仅仅是特定的重载。 标题是：<iterator>，<array>，<deque>，<forward_list>，<list>，<*map>*，<regex>，<set>，<string>，<unordered_map>，<unordered_set>和<vector>。

相反，在头<initializer_list>和<valarray>中，end被重载（具有不同的定义）。

参数

1. cont
   定义成员结束的类类型的对象。
2. arr
   数组。

返回值

对于（1），与cont.end（）返回的相同。
对于（2），指向将跟随数组中最后一个元素的元素的指针。

// std::begin / std::end example
#include <iostream>     // std::cout
#include <vector>       // std::vector, std::begin, std::end

int main () {
  int foo[] = {10,20,30,40,50};
  std::vector<int> bar;

  // iterate foo: inserting into bar
  for (auto it = std::begin(foo); it!=std::end(foo); ++it)
    bar.push_back(*it);

  // iterate bar: print contents:
  std::cout << "bar contains:";
  for (auto it = std::begin(bar); it!=std::end(bar); ++it)
    std::cout << ' ' << *it;
  std::cout << '\n';

  return 0;
}

数据范围

访问该参数但未修改。
调用不会访问序列中的任何元素，但返回的迭代器可用于访问或修改它们。

异常

提供与对参数执行的操作相同级别的保证（对于标准容器和数组，这是一种无抛出保证）。

五、prev

头文件iterator

template <class BidirectionalIterator>
  BidirectionalIterator prev (BidirectionalIterator it,
       typename iterator_traits<BidirectionalIterator>::difference_type n = 1);

获取前一个元素的迭代器
返回一个迭代器，指向如果高级-n位置它将指向的元素。

如果它是随机访问迭代器，则该函数仅使用一次operator +或operator-。 否则，该函数在复制的迭代器上重复使用增加或减少运算符（operator ++或operator–），直到n个元素被提前。

参数

1. it
   迭代器到基地位置。
   BidirectionalIterator至少应该是一个双向迭代器。
2. n
   元素位置偏移量（默认为1）。
   difference_type是表示BidirectionalIterator类型的迭代器之间的距离的数字类型。

返回值

元素n的迭代器位于it之前。

// prev example
#include <iostream>     // std::cout
#include <iterator>     // std::next
#include <list>         // std::list
#include <algorithm>    // std::for_each

int main () {
  std::list<int> mylist;
  for (int i=0; i<10; i++) mylist.push_back (i*10);

  std::cout << "The last element is " << *std::prev(mylist.end()) << '\n';

  return 0;
}

复杂度

随机访问迭代器的常量。
对于双向迭代器，n为线性。

迭代器有效性

没有效果。

数据范围

该函数访问迭代器，但它永远不会被解引用（调用不会访问指向的对象）。

异常

如果对复制的迭代器执行的任何算术运算抛出，则抛出，提供与此类操作相同的保证级别。

六、next

头文件iterator

template <class ForwardIterator>
  ForwardIterator next (ForwardIterator it,
       typename iterator_traits<ForwardIterator>::difference_type n = 1);

获取下一个元素的迭代器
返回一个迭代器，指向如果高级n位置它将指向的元素。

它没有被修改。

如果它是随机访问迭代器，则该函数仅使用一次operator +或operator-。 否则，该函数在复制的迭代器上重复使用增加或减少运算符（operator ++或operator–），直到n个元素被提前。

参数

1. it
   迭代器到基地位置。
   ForwardIterator至少应是一个前向迭代器。
2. n
   元素位置偏移量（默认为1）。
   这对随机访问和双向迭代器只是负面的。
   difference_type是表示ForwardIterator类型的迭代器之间的距离的数字类型。

返回值

元素n的迭代器远离it。

// next example
#include <iostream>     // std::cout
#include <iterator>     // std::next
#include <list>         // std::list
#include <algorithm>    // std::for_each

int main () {
  std::list<int> mylist;
  for (int i=0; i<10; i++) mylist.push_back (i*10);

  std::cout << "mylist:";
  std::for_each (mylist.begin(),
                 std::next(mylist.begin(),5),
                 [](int x) {std::cout << ' ' << x;} );

  std::cout << '\n';

  return 0;
}

复杂度

随机访问迭代器的常量。
否则，线性为n。

迭代器有效性

没有效果。

数据范围

该函数访问迭代器，但它永远不会被解引用（调用不会访问指向的对象）。

异常

如果对复制的迭代器执行的任何算术运算抛出，则抛出，提供与此类操作相同的保证级别。