Standard Template Library(STL，标准模板库)
STL（标准模板库）是C++标准程序库的核心，它深刻影响了标准程序库的整体结构。
STL是一个泛型(generic)程序库，提供一系列软件方案，利用先进，高效的算法来管理数据。
STL的所有组件都由template（模板）构成，故其元素可以是任意型别。
STL组件（STL Components）
通过C++开发者们精心设计的组件，共同构筑起了STL的基础。而在这些组件之中最为重要的要数迭代器，容器，算法
- 容器 Containers ，用来管理某类对象的合计。STL库的中每一个容器都会有其自身的优缺点，所以为了应付程序中的不同需求，STL准备了不同的容器类型，例如dynamic arrays,linked list,binary tree等
- 迭代器 Iterators，用来在一个对象群集的元素上进行相关的遍历动作。而使用迭代器的主要好处则是，为所有的容器提供一组很小的且相对安全的公共接口。而利用这个接口，某项操作就可以在这个容器对象的集群运行，或者行进至群集内的下一个元素
（注：迭代器的接口和一般的指针差不多，以operator++累进，以operator* 指向所指的元素值。因而，我们可以将迭代器视为一种smart poiner，能够把“前进至下一个元素”的意图转换成合适的操作
- 算法 Algorithms，用来处理群集内的元素
STL的基本观念就是将数据和操作分离。（重中之重）
数据由容器类别加以管理，操作则由可定制的算法定义之。迭代器在二者之间从当粘合剂，使其任何算法都可以和任何容器交互运作
STL的一个根本特性：所有组件都可以针对任意性别运作。顾名思义，所谓的Standard template library表示其内的所有组件都是“可接受任意型别”的template,前提是这些型别能够执行必要的操作。故，STL成了泛型编程（generic programming）概念下的一个出色案例
STL当然也能够提供更加泛型化的组件。通过特定的配接器和仿函数，使用者可以补充，约束或者订制算法，满足特别的需求
容器 （Containers）
容器类别（简称为容器）用来管理一组元素。为了适应不同的需求，STL提供了不同类型的容器
总的来说，STL的容器可分为两类：
- 序列式容器Sequence containers，此乃可序群集，其中的每个元素均有固定位置—取决于插入元素的时机和其地址，与元素值本身无关。STL提供三个定义好的序列式容器：vector,deque,list
- 关联式容器Associative container，此乃已序群集，元素位置取决于特定的排序准则。如果你将六个元素置于这样的群集中，则它们的位置取决于元素本身的值，和元素的插入次序无关。STL提供了四个关联式容器：set,multiset,map,multimap
关联式容器也可被视为特殊的序列式容器，因为已序群集正是根据某个排序准则排列而成
**注意事项：**STL所提供的群集型别彼此独立，各自实现，毫无关联，即其间并无classes继承关系
关联式容器自动对其元素进行排序，这并不意味着它就是用来排序的。当然，STL的使用者可以对序列式容器的元素加以手动排序。而关联式自动对其元素进行排序的主要优点是，当你搜寻元素时，可获得更佳的效率，自动排序只不过是关联式容器的一个有用的副作用而已
注：客观来说，对关联式容器插入大量元素进行排序与一次性对Vector插入大量元素在进行排序所损耗的时间相比，vector所耗费的时间更少，效率更佳
序列式容器（Sequence containers）
STL内部预先定义好了以下三个序列式的容器：
- vector
- deque
- list
此外，你也可将string和array当作一种序列式容器
Vector
Vector将其元素置于一个dynamic array中加以管理。它允许随机存取，也就是你可以利用索引直接存取任何一个元素。在vector尾部附加元素或者移除元素均非常的快速，但在array中部或者头部安插元素就比较费时费力了
#include<iostream>
#include<vector>
using namespace std;
int main()
{
vector<int> vi;
for(int i=1;i<=6;++i)
vi.push_back(i);
for(int i=0;i<vi.size();++i)
cout<<vi[i]<<ends;
cout<<endl;
return 0;
}
程序输出结果：
1 2 3 4 5 6
知识点：
- #include< vector >含入vectors的头文件
- push_back()函数可为容器的尾部安插元素
- size()成员函数返回容器中的元素的个数
- 可通过subscript（下标）操作符[]，存取vector内的某个元素
Deque
所谓deque，是“double-ended queue”的缩写。它是一个dynamic array，可以向两端发展，因此不论在尾部或者是头部安插元素都十分的迅速。在中间部分安插元素则比较费时费力，因为必须移动其他元素
#include<iostream>
#include<deque>
using namespace std;
int main()
{
deque<double> dd;
for(int i=1;i<=6;++i)
dd.push_front(i*1.1);
for(auto it=dd.begin();it!=dd.end();++it)
cout<<*it<<ends;
cout<<endl;
return 0;
}
程序输出结果：
6.6 5.5 4.4 3.3 2.2 1.1
知识点：
- #include< deque>含入deques的头文件
- push_front()函数可为容器的头部安插元素
- begin()成员函数返回容器中第一个元素的地址，end()成员函数返回容器中最后一个元素的地址
push_front()函数会将元素安插于群集前端。需要注意的是，这种安插方式造成的结果就是，元素排放的次序与安插次序恰好相反，因为每个元素都安插于上一个元素的前面
当然，我们也可使用成员函数push_back()在deque尾端附加元素。vector并未提供push_front()函数，因为这样做的话，其时间性能很差，在vector的头端安插一个元素，需要移动全部的元素！
一般而言，STL容器只提供通常具备良好时间效能的成员函数（所谓“良好”的时间效能，通常意味着具有常数复杂度或者对数复杂度），以防止程序员调用性能很差的函数
List
List由双向链表（double linked list）实作而成。这意味着list内的每个元素都以一部分内存指示其前趋元素和后继元素。List不提供随机存取
List的优势：在任何位置上执行安插或删除动作动作都非常迅速，因为只须改变链接（links）就行。这表示在list中间位置移动元素比在vector和deque快得多
#include<iostream>
#include<list>
using namespace std;
int main()
{
list<char> lc;
for(char c='a';c<='z';++c)
lc.push_back(c);
while(!lc.empty()) {
cout<<lc.front()<<ends;
lc.pop_front();
}
cout<<endl;
return 0;
}
程序输出结果：
a b c d e f g h i j k l m n o p q r s t u v w x y z
知识点：
- #include< list >含入list的头文件
- empty()成员函数的返回值告诉我们容器中是否还有元素
- front()成员函数会返回容器的第一个元素
- pop_front()成员函数会删除容器中的第一个元素，需要注意的是pop_front()并不会返回被删除的元素
lists并没有提供以operator[]直接存取元素的能力，因为lists不支持随机存取，如果采用operator[]会导致不良效能。使用迭代器一样可以遍历并打印所有元素
Arrays
这种容器不是类别（class），而是C/C++语言核心所支持的一个型别(type)：具有静态大小或者动态大小的array
#include<iostream>
#include<array>
using namespace std;
int main()
{
array<int,6> ai = { 1,2,3,4,5,6 };
for(auto it=ai.begin();it!=ai.end();++it)
cout<<*it<<ends;
cout<<endl;
return 0;
}
程序输出结果：
1 2 3 4 5 6
关联式容器（Associative Containers）
关联式容器依据特定的排序准则，自动为其元素排序。排序准则以函数形式呈现，用来比较元素值（value）或元素键（key）。通常关联式容器由二叉树（binary tree）视作出来。在二叉树中，每个元素(节点)都有一个父节点和两个子节点；左子树的所有元素都比自己小，右子树的所有元素都比自己大
关联式容器的差别主要在于元素的类型以及处理重复元素时的方式（态度）
- Sets
Set的内部元素依据其值自动排序，每个元素值只能出现一次，不允许重复
- Multisets
Multisets和set相同，只不过它允许重复元素，也就是说multiset可包含多个数值相同的元素
- Maps
Map的元素都是“实值/键值”所形成的一个对组(key/value pairs)。每个元素有一个键，是排序准则的基础。每一个键只能出现一次，不允许重复。Map可被视为关联式数组，也就是具有任意索引型别的数组
- Multimaps
Multimap和map相同，但允许重复元素，也就是说multimap可包含多个键值(key)相同的元素。Multimap可被当作“字典”使用
我们可以将set视为一种特殊的map：其元素实值就是键值。实际产品中，所有这些关联式容器通常都由二叉树（binary tree）实作而成
Set和Muliset
#include<iostream>
#include<set>
using namespace std;
int main()
{
typedef set<int> IntSet;
IntSet I_set;
I_set.insert(3);
I_set.insert(5);
I_set.insert(1);
I_set.insert(2);
I_set.insert(4);
I_set.insert(1); // 重复插入，忽略该操作
IntSet::iterator it;
for(it=I_set.begin();it!=I_set.end();++it)
cout<<*it<<ends;
cout<<endl;
return 0;
}
程序输出结果：
1 2 3 4 5
知识点：
- #include< set >含入set和muliset的头文件
- 所有关联式容器都提供有一个insert()成员函数，用来安插新元素，新元素会根据排序准则自动安插到正确的位置
- 需要注意的是，我们不能使用序列容器的push_back()和push_front()函数，它们在这里毫无意义，因为我们没有权力指定新元素的位置
- 如果你想用multiset而不是set，唯一需要改变的就是容器的型别（set和multiset的设定被置于同一个头文件中）
Maps和Multimaps
Map的元素是成对的键值/实值(key/valule)。因此其声明，元素安插，元素存取皆和set有所不同，以下为multimap的使用案例：
#include<iostream>
#include<map>
#include<string>
using namespace std;
int main()
{
typedef multimap<int,string> IntStringMMap;
IntStringMMap coll;
coll.insert(make_pair(5,"tagged"));
coll.insert(make_pair(2,"a"));
coll.insert(make_pair(1,"this"));
coll.insert(make_pair(4,"of"));
coll.insert(make_pair(6,"strings"));
coll.insert(make_pair(1,"is"));
coll.insert(make_pair(3,"multimap"));
IntStringMMap::iterator it;
for(it=coll.begin();it!=coll.end();++it)
cout<<it->second<<ends;
cout<<endl;
return 0;
}
程序输出结果：
this is a multimap of tagged strings
知识点：
- #include< map >含入map和mulimap的头文件
- map容器中的元素是成对的键值/实值(key/value pair)，所以你必须首先生成这个pair，再将它插入群集内部。辅助函数make_pair()正是为了这个目的而打造的
- 迭代器所指的是“键值/实值”对组（key/value pair），因此我们无法一口气打印它们，必须取出pair的成员，亦即所谓的first和second
将Maps当做关联式数组
一个“键值/实值”对组所形成的群集中，如果所有键值都是独一无二的，我们可将它视为一个关联式数组（associative array）
#include<iostream>
#include<map>
#include<string>
using namespace std;
int main()
{
typedef map<string,double> StringDoubleMap;
StringDoubleMap Dic;
// 如果我们指定一个容器里不存在的索引，会导致产生一个对应的新元素
Dic["VAT"] = 0.15;
Dic["Pi"] = 3.1415;
Dic["an arbitrary number"] = 12345.4321;
Dic["Null"] = 0;
StringDoubleMap::iterator it;
for(it=Dic.begin();it!=Dic.end();++it)
cout<<"key: "<<it->first<<ends<<"value: "<<it->second<<endl;
return 0;
}
程序输出结果：
key: Null value: 0
key: Pi value: 3.1415
key: VAT value: 0.15
key: an arbitrary number value: 12345.4
知识点：
-
当我们声明容器型别时，必须同时指定键值（key）和实值（value）的型别(type)
-
Maps允许我们使用operator[]安插元素
-
我们俗称的关联数组就是，索引可以采用任何型别(type)
-
Multimaps不允许我们使用subscript(下标)操作符，因为multimaps允许单一索引对应到多个不同元素，而下标操作符却只能处理单一实值
-
存取multimaps或maps的元素时，我们必须透过pair结构的first成员和second成员，才能取得键值(key)和实值(value)
容器配接器（Container Adapter）
除了以上数个根本的容器类别，为满足特殊的需求，C++标准程序库还提供了一些特别的（并且预先定义好的）容器配接器，根据基本容器类别实作而成
- Stacks
Stack容器对容器采取LIFO（后进先出）管理策略
- Queues
Queue容器对元素采取FIFO（先进先出）管理策略。也就是说，它是一个普通的缓冲区(buffer)
- Priority Queues
Priority Queues容器中的元素可以拥有不同的优先权。该容器所谓的优先权，乃是基于程序员提供的排序准则（缺省时使用operator<）而定义。Priority Queues的效果相当于这样的一个buffer：“下一个元素永远是queue中优先级最高的元素”
迭代器（Iterators）
迭代器是一个“可遍历STL容器内全部或部分元素”的对象。一个迭代器用来指出容器中的一个特定位置
基本操作如下:
- operator*
返回当前位置上的元素值。如果该元素拥有成员，你可以透过迭代器，直接以operator->取用它们
- operator++
将迭代器前进至下一元素。大多数迭代器还可使用operator–退回到前一个元素
- operator==和operator!=
判断两个迭代器是否指向同一位置
- operator=
为迭代器赋值(将其所指元素的位置赋值过去)
以上这些操作和C/C++“操作array元素”时的指针接口一致。其不同之处在于，迭代器是个所谓的smart pointers，具有遍历复杂数据结构的能力，迭代器下层的运行机制取决于其所遍历的数据结构。因此，每一种容器类型都必须提供自己的迭代器
事实上，每一种容器都将其迭代器以嵌套的方式定于容器的内部。因此我们可以发现，各种迭代器的接口相同，型别却不同
而以上的思想便因此引出了泛型程序设计的概念：所有操作行为都使用相同接口，虽然它们的型别不同。因此，我们可以使用template将泛型操作公式化，使之得以顺利运行那些“能够满足接口需求”的任何型别
容器类型中，与迭代器相关且经常使用的成员函数：
- begin()
返回一个迭代器，指向容器的起始点，也就是第一元素（如果有的话）的位置
- end()
返回一个迭代器，指向容器的结束点。结束点在最后一个元素之后，这样的迭代器又称为“逾尾（past-the-end）”迭代器
通过以上两个成员函数，begin()和end()形成了一个半开区间（half-open range），从第一个元素开始，到最后一个元素的下一个位置结束。
这样的半开区间有两个优点：
- 为“遍历元素时，循环的结束时机”提供了一个简单的判断依据。只要尚未到达end()，循环就可以继续进行
- 不必对空区间特殊处理手法。空区间的begin()就等于end()
迭代器简单使用的案例：
#include<iostream>
#include<list>
using namespace std;
int main()
{
list<char> lc;
for(char c='a';c<='z';++c)
lc.push_back(c);
list<char>::const_iterator cit;
for(cit=lc.begin();cit!=lc.end();++cit)
cout<<*cit<<ends;
cout<<endl;
return 0;
}
程序输出结果：
a b c d e f g h i j k l m n o p q r s t u v w x y z
知识点：
- 迭代器cit声明于循环之前，其型别是“指向容器中的不可变元素”的迭代器
- 任何一种容器都定义有两种迭代器型别：
- container::iterator - 这种迭代器以“读/写”模式遍历元素
- container::const_iterator - 这种迭代器以“只读”模式遍历元素
总的来说，迭代器cit从第一个元素开始，逐一访问了每一个元素，直到抵达结束点为止。如果容器内没有任何元素，lc.begin()等于lc.end()，循环根本不会执行
循环代码：
list<char>::const_iterator cit;
for(cit=lc.begin();cit!=lc.end();++cit)
cout<<*cit<<ends;
需要我们注意的是，在该循环的代码中，我们使用了“前置型递增(preincrement)"++cit，因为它比”后置式递增(postincrement)“cit++效率高。因为，后置式的递增需要一个额外的临时对象，因为它必须存放迭代器的原本位置并将它返回，所以一般情况下最好使用++cit
故，我们建议优先采用前置式递增和前置式递减操作符
迭代器分类
STL总是只提供效率上比较出色的操作，因此，如果容器允许随机存取（例如vectors或deques），那么它们的迭代器也能进行随机操作
STL预先定义好的所有容器，其迭代器均属于以下两种类型：
- 双向迭代器（Bidirectional iterator）
顾名思义，双向迭代器可以进行双向行进：以递增运算前进或以递减运算后退。list,set,multiset,map和multimap这些容器所提供的迭代器都属此类
- 随机存取迭代器（Random access iterator）
随机存取迭代器不但具备双向迭代器的所有属性，还具备随机访问的能力。更明确地说，它们提供了“迭代器算术运算”必要的操作符（和“一般指针的算术运算”完全对应）。vector，deque和strings所提供的迭代器都属此类
注：但，为了撰写尽可能与容器型别无关的泛型程序代码，我们最好不要使用随机存取迭代器所特有的操作
算法（Algorithms）
为了处理容器内的元素，STL提供了一些标准算法，包括搜寻，排序，拷贝，重新排序，修改，数值运算等十分基本而普遍的算法
算法并非容器类别的成员函数，而是一种搭配迭代器使用的全局函数，这样的好处在于，所有算法只需实作一份，就可以对所有容器运作，不必为每一种容器量身定制
#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
int main()
{
vector<int> vi;
vector<int>::iterator it;
vi.push_back(2);
vi.push_back(1);
vi.push_back(5);
vi.push_back(4);
vi.push_back(6);
vi.push_back(3);
it = min_element(vi.begin() ,vi.end());
cout<<"min: "<<*it<<endl;
it = max_element(vi.begin() ,vi.end());
cout<<"max: "<<*it<<endl;
sort(vi.begin() ,vi.end());
for(it=vi.begin();it!=vi.end();++it)
cout<<*it<<ends;
cout<<endl;
it = find(vi.begin(),vi.end(),3);
reverse(it,vi.end());
for(it=vi.begin();it!=vi.end();++it)
cout<<*it<<ends;
cout<<endl;
return 0;
}
程序输出结果：
min: 1
max: 6
1 2 3 4 5 6
1 2 6 5 4 3
知识点：
- 为了调用算法，你必须含入头文件< algorithm >
- 算法min_element()返回最小元素的位置（如果最小元素不只一个，则返回第一个最小元素的位置）
- 算法max_element()返回最大元素的位置（如果最大元素不只一个，则返回第一个最小元素的位置）
- 算法sort()，顾名思义，将“由两个参数设定出来”的区间内的所有元素加以排序，我们可以有选择性传入一个排序准则
- 算法find()，它在给定范围中搜寻某个值，如果find()成功了，便返回一个迭代器，指向目标元素，如果失败，返回一个“逾尾”迭代器，亦即find()所接受的第二参数
- 算法reverse()，将区间内的元素反转放置
处理多个区间
有数个算法（或者说需要）同时处理多个区间，通常来看，我们必须设定第一个区间的起点和终点，至于其他区间，你只需设定起点即可，终点通常可由第一区间元素数量推导出来。
案例：算法equal()从头开始逐一比较vi_1和vi_2的所有元素
if(equal(vi_1.begin(),vi_1.end(),vi_2.begin())) {
....
}
vi_2之中参与比较的元素数量，间接取决于vi_2内的元素数量
注：如果某个算法用来处理多个区间，那么当我们调用它时，务必确保第二（以及其他）区间拥有的元素个数，至少和第一区间内的元素个数相同。特别是，执行涂写动作时，务必确保目标区间够大
#include<iostream>
#include<vector>
#include<list>
#include<algorithm>
using namespace std;
int main()
{
list<int> li(9);
vector<int> vi;
for(int i=1;i<=9;++i)
vi.push_back(i);
copy(vi.begin(),vi.end(),li.begin());
for(auto it=li.begin();it!=li.end();++it)
cout<<*it<<ends;
cout<<endl;
return 0;
}
程序输出结果：
1 2 3 4 5 6 7 8 9
知识点：
- 算法copy()，将第一区间内的全部元素拷贝至目标区间，第一区间的起点和终点都已指定，第二区间只指出起点。然而，由于该算法执行的是覆写动作而非安插操作，所以目标区间必须拥有足够的元素来被覆写
- 要想让目标区间够大，你要不一开始就给它一个正确大小，要不就显式地改变其大小。这两个办法都只适用于序列式容器（vectors,deques,lists）
- 关联式容器不可能被当做覆写型算法的操作目标
迭代器之配接器（Iterator Adapters）
迭代器(Iterators)是一个相对纯粹的抽象概念，任何的东西，只要其行为类似迭代器，它就是一个迭代器。C++标准程序库提供了数个预先定义的特殊迭代器，亦即所谓迭代器配接器（iterator adapters）。它们不仅起辅助作用，还能赋予整个迭代器抽象概念更强大的能力
以下介绍三种迭代器配接器（iterator adapters）：
- Insert iterators（安插型迭代器）
- Stream iterators（流迭代器）
- Reverse iterators（逆向迭代器）
Insert Iterators(安插型迭代器)
Inserters可以使算法以安插(insert)方式而非覆写(overwrite)方式运作。使用它，可以解决算法的“目标空间不足”问题
Inserter iterators内部将接口做了新的定义：
- 如果我们对某个元素设值(assign)，会引发“对其所属群集的安插(insert)操作"。至于插入位置，则视三种不同的insert iterators而定
#include<iostream>
#include<vector>
#include<deque>
#include<list>
#include<set>
#include<algorithm>
#include<iterator>
using namespace std;
void print(int val) {
cout<<val<<ends;
}
int main()
{
list<int> li;
for(int i=1;i<=9;++i)
li.push_back(i);
for_each(li.begin(),li.end(),print);
cout<<endl<<endl;
vector<int> vi;
copy(li.begin(),li.end(),back_inserter(vi));
for_each(vi.begin(),vi.end(),print);
cout<<endl<<endl;
deque<int> di;
copy(li.begin(),li.end(),front_inserter(di));
for_each(di.begin(),di.end(),print);
cout<<endl<<endl;
set<int> si;
copy(li.begin(),li.end(),inserter(si,si.begin()));
for_each(si.begin(),si.end(),print);
cout<<endl;
return 0;
}
程序输出结果：
1 2 3 4 5 6 7 8 9
1 2 3 4 5 6 7 8 9
9 8 7 6 5 4 3 2 1
1 2 3 4 5 6 7 8 9
知识点：
1.Back_inserters（安插于容器最尾端）
Back_inserters的内部调用push_back()，在容器尾端插入元素（即”追加“动作）；只有在提供有push_back()成员函数的容器中，back_inserters才能派上用场，即vector，deque，list
2.Front_inserters（安插于容器最前端）
Front_inserters的内部调用push_front()，在容器尾端插入元素（即”追加“动作）；只有在提供有push_front()成员函数的容器中，front_inserters才能派上用场，即deque和list
3.General inserters（一般性安插器）
这种一般性的inserters，简称就叫inserts，它的作用是将元素插入”初始化时接收之第二参数“所指位置的前方。Inserts内部调用成员函数insert()，并以新值和新位置作为参数。所有STL容器都提供有insert()成员函数，因此，这是唯一可用于关联式容器身上的一种预先定义好的inserter
Stream Iterators（流迭代器）
另一种非常有用的迭代器配接器是stream iterator，这是一种用来读写stream的迭代器
#include<iostream>
#include<vector>
#include<string>
#include<algorithm>
#include<iterator>
using namespace std;
int main()
{
vector<string> vs;
copy(istream_iterator<string>(cin),istream_iterator<string>(),back_inserter(vs));
sort(vs.begin(),vs.end());
unique_copy(vs.begin(),vs.end(),ostream_iterator<string>(cout,"\n"));
return 0;
}
知识点：
-
istream_iterator<string>(cin)这会产生一个可从”标准输入流cin“读取数据的stream iterator。其中template参数string表示这个stream iterator专门读取该种型别的元素的职责 -
istream_iterator<string>()调用istream iterators的default构造函数，产生一个代表”流结束符号“的迭代器，它代表的意义是：你不能再从中读取任何东西 - 关于算法copy()：只要不断逐一前进的那个第一参数不同于第二参数，算法copy()就持续动作
- 算法unique_copy()在处理的过程中会消除毗邻的重复值
Reverse Iterator（逆向迭代器）
第三种预先定义的迭代器配接器就是reverse iterators，此物像是倒转经脉似地以逆向方式进行所有操作。它将递增运算转换韦递减运算，反之亦然。所有容器都可以透过成员函数rbegin()和rend()产生出reverse iterator
#include<iostream>
#include<vector>
#include<algorithm>
#include<iterator>
using namespace std;
int main()
{
vector<int> vi;
for(int i=1;i<=9;++i)
vi.push_back(i);
copy(vi.rbegin(),vi.rend(),ostream_iterator<int>(cout," "));
cout<<endl;
return 0;
}
程序输出结果：
9 8 7 6 5 4 3 2 1
知识点：
- 当某个位置上并没有任何合法元素时，我们永远不要使用operator* 或 operator->
eam iterator。其中template参数string表示这个stream iterator专门读取该种型别的元素的职责
-
istream_iterator<string>()调用istream iterators的default构造函数，产生一个代表”流结束符号“的迭代器，它代表的意义是：你不能再从中读取任何东西 - 关于算法copy()：只要不断逐一前进的那个第一参数不同于第二参数，算法copy()就持续动作
- 算法unique_copy()在处理的过程中会消除毗邻的重复值
Reverse Iterator（逆向迭代器）
第三种预先定义的迭代器配接器就是reverse iterators，此物像是倒转经脉似地以逆向方式进行所有操作。它将递增运算转换韦递减运算，反之亦然。所有容器都可以透过成员函数rbegin()和rend()产生出reverse iterator
#include<iostream>
#include<vector>
#include<algorithm>
#include<iterator>
using namespace std;
int main()
{
vector<int> vi;
for(int i=1;i<=9;++i)
vi.push_back(i);
copy(vi.rbegin(),vi.rend(),ostream_iterator<int>(cout," "));
cout<<endl;
return 0;
}
程序输出结果：
9 8 7 6 5 4 3 2 1
知识点：
- 当某个位置上并没有任何合法元素时，我们永远不要使用operator* 或 operator->