标签：容器 iterator 迭代 STL 元素 Library Standard include

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的容器可分为两类：

1. 序列式容器Sequence containers，此乃可序群集，其中的每个元素均有固定位置—取决于插入元素的时机和其地址，与元素值本身无关。STL提供三个定义好的序列式容器：vector,deque,list
2. 关联式容器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），从第一个元素开始，到最后一个元素的下一个位置结束。

这样的半开区间有两个优点：

1. 为“遍历元素时，循环的结束时机”提供了一个简单的判断依据。只要尚未到达end()，循环就可以继续进行
2. 不必对空区间特殊处理手法。空区间的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声明于循环之前，其型别是“指向容器中的不可变元素”的迭代器
• 任何一种容器都定义有两种迭代器型别：

1. container::iterator - 这种迭代器以“读/写”模式遍历元素
2. 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）：

1. Insert iterators（安插型迭代器）
2. Stream iterators（流迭代器）
3. 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;
}

知识点：

1. istream_iterator<string>(cin) 这会产生一个可从”标准输入流cin“读取数据的stream iterator。其中template参数string表示这个stream iterator专门读取该种型别的元素的职责
2. istream_iterator<string>()调用istream iterators的default构造函数，产生一个代表”流结束符号“的迭代器，它代表的意义是：你不能再从中读取任何东西
3. 关于算法copy()：只要不断逐一前进的那个第一参数不同于第二参数，算法copy()就持续动作
4. 算法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专门读取该种型别的元素的职责

2. istream_iterator<string>()调用istream iterators的default构造函数，产生一个代表”流结束符号“的迭代器，它代表的意义是：你不能再从中读取任何东西
3. 关于算法copy()：只要不断逐一前进的那个第一参数不同于第二参数，算法copy()就持续动作
4. 算法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->

标签：容器,iterator,迭代,STL,元素,Library,Standard,include
来源： https://blog.csdn.net/weixin_51958878/article/details/123139930

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。