本篇文章转载，请点击原文
begin()：返回一个迭代器，指向容器终点，即第一个元素（如果有的话）的位置。
end()：返回一个迭代器，指向容器终点。终点位于最末元素的下一位置，又称“逾尾迭代器”。
对容器而言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;
...
}
（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迭代器都属此类。
（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()后面则会产生越界。
（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所指的值迭代器的类型不必相同，但其所指的两个值必须可以互相赋值
（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)，例如把它们搬移到一个新容器内。
