【C++】迭代器、反向迭代器详解
参考:
- http://c.biancheng.net/view/338.html
- https://blog.csdn.net/kjing/article/details/6936325
- https://blog.csdn.net/qq_22194315/article/details/57144854
一、迭代器
1. 概述
要访问顺序容器和关联容器中的元素,需要通过“迭代器(iterator)”进行。迭代器是一个变量,相当于容器和操纵容器的算法之间的中介。迭代器可以指向容器中的某个元素,通过迭代器就可以读写它指向的元素。从这一点上看,迭代器和指针类似。
迭代器按照定义方式分成以下四种:
- 正向迭代器,定义方法如下:
容器类名::iterator 迭代器名;
- 常量正向迭代器,定义方法如下:
容器类名::const_iterator 迭代器名;
- 反向迭代器,定义方法如下:
容器类名::reverse_iterator 迭代器名;
- 常量反向迭代器,定义方法如下:
容器类名::const_reverse_iterator 迭代器名;
2. 迭代器用法示例
通过迭代器可以读取它指向的元素,*迭代器名
就表示迭代器指向的元素。通过非常量迭代器还能修改其指向的元素。迭代器都可以进行++
操作。
反向迭代器和正向迭代器的区别在于:对正向迭代器进行++
操作时,迭代器会指向容器中的后一个元素;而对反向迭代器进行++
操作时,迭代器会指向容器中的前一个元素。
下面的程序演示了如何通过迭代器遍历一个 vector
容器中的所有元素:
#include <iostream>
#include <vector>
using namespace std;
int main()
{vector<int> v; //v是存放int类型变量的可变长数组,开始时没有元素for (int n = 0; n<5; ++n)v.push_back(n); //push_back成员函数在vector容器尾部添加一个元素vector<int>::iterator i; //定义正向迭代器for (i = v.begin(); i != v.end(); ++i) { //用迭代器遍历容器cout << *i << " "; //*i 就是迭代器i指向的元素*i *= 2; //每个元素变为原来的2倍}cout << endl;//用反向迭代器遍历容器for (vector<int>::reverse_iterator j = v.rbegin(); j != v.rend(); ++j)cout << *j << " ";return 0;
}// 程序的输出结果是:
0 1 2 3 4
8 6 4 2 0
第 6 行:
vector
容器有多个构造函数,如果用无参构造函数初始化,则容器一开始是空的。第 10 行:
begin
成员函数返回指向容器中第一个元素的迭代器。++i
使得i
指向容器中的下一个元素。end
成员函数返回的不是指向最后一个元素的迭代器,而是指向最后一个元素后面的位置的迭代器,因此循环的终止条件是i != v.end()
。第 16 行:定义了反向迭代器用以遍历容器。反向迭代器进行
++
操作后,会指向容器中的上一个元素。rbegin
成员函数返回指向容器中最后一个元素的迭代器,rend
成员函数返回指向容器中第一个元素前面的位置的迭代器,因此本循环实际上是从后往前遍历整个数组。
注意:如果迭代器指向了容器中最后一个元素的后面或第一个元素的前面,再通过该迭代器访问元素,就有可能导致程序崩溃,这和访问 NULL 或未初始化的指针指向的地方类似。第 10 行和第 16 行:写
++i
、++j
相比于写i++
、j++
,程序的执行速度更快。回顾++
被重载成前置和后置运算符的例子如下:
CDemo CDemo::operator++ ()
{ //前置++++n;return *this;
}
CDemo CDemo::operator ++(int k)
{ //后置++CDemo tmp(*this); //记录修改前的对象n++;return tmp; //返回修改前的对象
}
后置++
要多生成一个局部对象 tmp
,因此执行速度比前置的慢。同理,迭代器是一个对象,STL 在重载迭代器的++
运算符时,后置形式也比前置形式慢。在次数很多的循环中,++i
和i++
可能就会造成运行时间上可观的差别了。因此,本教程在前面特别提到,对循环控制变量i
,要养成写++i
、不写i++
的习惯。
注意:容器适配器 stack
、queue
和 priority_queue
没有迭代器。容器适配器有一些成员函数,可以用来对元素进行访问。
3. 迭代器的功能分类
不同容器的迭代器,其功能强弱有所不同。容器的迭代器的功能强弱,决定了该容器是否支持 STL 中的某种算法。例如,排序算法需要通过随机访问迭代器来访问容器中的元素,因此有的容器就不支持排序算法。
常用的迭代器按功能强弱分为:输入、输出、正向、双向、随机访问五种,这里只介绍常用的三种:
正向迭代器。假设
p
是一个正向迭代器,则p
支持以下操作:++p
,p++
,*p
。此外,两个正向迭代器可以互相赋值,还可以用==
和!=
运算符进行比较。双向迭代器。双向迭代器具有正向迭代器的全部功能。除此之外,若
p
是一个双向迭代器,则--p
和p--
都是有定义的。--p
使得p
朝和++p
相反的方向移动。随机访问迭代器。随机访问迭代器具有双向迭代器的全部功能。若
p
是一个随机访问迭代器,i
是一个整型变量或常量,则p
还支持以下操作:
p+=i
:使得p
往后移动i
个元素。
p-=i
:使得p
往前移动i
个元素。
p+i
:返回p
后面第i
个元素的迭代器。
p-i
:返回p
前面第i
个元素的迭代器。
p[i]
:返回p
后面第i
个元素的引用。此外,两个随机访问迭代器
p1、p2
还可以用<、>、<=、>=
运算符进行比较。p1<p2
的含义是:p1
经过若干次(至少一次)++
操作后,就会等于p2
。其他比较方式的含义与此类似。对于两个随机访问迭代器
p1、p2
,表达式p2-p1
也是有定义的,其返回值是p2
所指向元素和p1
所指向元素的序号之差(也可以说是p2
和p1
之间的元素个数减一)。
下表所示为不同容器的迭代器的功能:
容器 | 迭代器功能 |
---|---|
vector | 随机访问 |
deque | 随机访问 |
list | 双向 |
set / multiset | 双向 |
map / multimap | 双向 |
stack | 不支持迭代器 |
queue | 不支持迭代器 |
priority_queue | 不支持迭代器 |
例如,vector
的迭代器是随机迭代器,因此遍历 vector
容器有以下几种做法。下面的程序中,每个循环演示了一种做法。
【实例】遍历 vector 容器:
#include <iostream>
#include <vector>
using namespace std;
int main()
{vector<int> v(100); //v被初始化成有100个元素for(int i = 0;i < v.size() ; ++i) //size返回元素个数cout << v[i]; //像普通数组一样使用vector容器vector<int>::iterator i;for(i = v.begin(); i != v.end (); ++i) //用 != 比较两个迭代器cout << * i;for(i = v.begin(); i < v.end ();++i) //用 < 比较两个迭代器cout << * i;i = v.begin();while(i < v.end()) { //间隔一个输出cout << * i;i += 2; // 随机访问迭代器支持 "+= 整数" 的操作}
}
list
容器的迭代器是双向迭代器。假设 v
和 i
的定义如下:
list<int> v;
list<int>::const_iterator i;
则以下代码是合法的:
for(i=v.begin(); i!=v.end(); ++i)
cout << *i;
以下代码则不合法:
for(i=v.begin(); i<v.end(); ++i)
cout << *i;
因为双向迭代器不支持用“<
”进行比较。以下代码也不合法:
for(int i=0; i<v.size(); ++i)
cout << v[i];
因为 list
不支持随机访问迭代器的容器,也不支持用下标随机访问其元素。
在 C++ 中,数组也是容器。数组的迭代器就是指针,而且是随机访问迭代器。例如,对于数组 int a[10]
,int *
类型的指针就是其迭代器。则 a、a+1、a+2
都是 a
的迭代器。
4. 迭代器的辅助函数
STL 中有用于操作迭代器的三个函数模板,它们是:
advance(p, n)
:使迭代器 p 向前或向后移动 n 个元素。distance(p, q)
:计算两个迭代器之间的距离,即迭代器 p 经过多少次 + + 操作后和迭代器 q 相等。如果调用时 p 已经指向 q 的后面,则这个函数会陷入死循环。iter_swap(p, q)
:用于交换两个迭代器 p、q 指向的值。
要使用上述模板,需要包含头文件 algorithm
。下面的程序演示了这三个函数模板的用法:
#include <list>
#include <iostream>
#include <algorithm> //要使用操作迭代器的函数模板,需要包含此文件
using namespace std;
int main()
{int a[5] = { 1, 2, 3, 4, 5 };list <int> lst(a, a+5);list <int>::iterator p = lst.begin();advance(p, 2); //p向后移动两个元素,指向3cout << "1)" << *p << endl; //输出 1)3advance(p, -1); //p向前移动一个元素,指向2cout << "2)" << *p << endl; //输出 2)2list<int>::iterator q = lst.end();q--; //q 指向 5cout << "3)" << distance(p, q) << endl; //输出 3)3iter_swap(p, q); //交换 2 和 5cout << "4)";for (p = lst.begin(); p != lst.end(); ++p)cout << *p << " ";return 0;
}// 程序的输出结果是:
1) 3
2) 2
3) 3
4) 1 5 3 4 2
二、反向迭代器
1. 概述
反向迭代器是一种反向遍历容器的迭代器。也就是,从最后一个元素到第一个元素遍历容器。反向迭代器将自增(和自减)的含义反过来了:对于反向迭代器,++
运算将访问前一个元素,而 --
运算则访问下一个元素。
回想一下,所有容器都定义了 begin
和 end
成员,分别返回指向容器首元素和尾元素下一位置的迭代器。这两个迭代器通常用于标记包含容器中所有元素的迭代范围。容器还定义了 rbegin
和 rend
成员,分别返回指向容器尾元素和首元素前一位置的反向迭代器。与普通迭代器一样,反向迭代器也有常量(const)和非常量(nonconst)类型。
c.begin()
返回一个迭代器,它指向容器c的第一个元素;c.end()
返回一个迭代器,它指向容器c的最后一个元素的下一个位置;c.rbegin()
返回一个逆序迭代器,它指向容器c的最后一个元素;c.rend()
返回一个逆序迭代器,它指向容器c的第一个元素前面的位置;上述每个操作都有两个不同的版本:一个是
const
成员,另一个是非const
成员。这些操作返回什么类型取决于容器是否为const
。如果容器不是const
,则这些操作返回iterator
或reverse_iterator
类型。如果容器是const
,则其返回类型要加上const_
前缀,也就是const_iterator
和const_reverse_iterator
类型。
2. 反向迭代器示例
假设有一个 vector
容器对象,存储 0-9 这 10 个以升序排列的数字:
vector<int> vec;for (vector<int>::size_type i = 0; i != 10; ++i)vec.push_back(i); // elements are 0,1,2,...9
下面的 for
循环将以逆序输出这些元素:
// reverse iterator of vector from back to frontvector<int>::reverse_iterator r_iter;for (r_iter = vec.rbegin(); // binds r_iter to last elementr_iter != vec.rend(); // rend refers 1 before 1st element++r_iter) // decrements iterator one elementcout << *r_iter << endl; // prints 9,8,7,...0
虽然颠倒自增和自减这两个操作符的意义似乎容易使人迷惑,但是它让程序员可以透明地向前或向后处理容器。例如,为了以降序排列 vector
,只需向 sort
传递一对反向迭代器:
// sorts vec in "normal" order
sort(vec.begin(), vec.end());
// sorts in reverse: puts smallest element at the end of vec
sort(vec.rbegin(), vec.rend());
反向迭代器需要使用自减操作符
从一个既支持
--
也支持++
的迭代器就可以定义反向迭代器,这不用感到吃惊。毕竟,反向迭代器的目的是移动迭代器反向遍历序列。标准容器上的迭代器既支持自增运算,也支持自减运算。但是,流迭代器却不然,由于不能反向遍历流,因此流迭代器不能创建反向迭代器。
3. 反向迭代器与其他迭代器之间的关系
假设有一个名为 line
的 string
对象,存储以逗号分隔的单词列表。我们希望输出 line
中的第一个单词。使用 find
可很简单地实现这个任务:
// find first element in a comma-separated liststring::iterator comma = find(line.begin(), line.end(), ',');cout << string(line.begin(), comma) << endl;
如果在 line
中有一个逗号,则 comma
指向这个逗号;否则,comma
的值为 line.end()
。在输出 string
对象中从 line.begin()
到 comma
的内容时,从头开始输出字符直到遇到逗号为止。如果该 string
对象中没有逗号,则输出整个 string
字符串。
如果要输出列表中最后一个单词,可使用反向迭代器:
// find last element in a comma-separated list
string::reverse_iterator rcomma = find(line.rbegin(), line.rend(), ',');
因为此时传递的是 rbegin()
和 rend()
,这个函数调用从 line
的最后一个字符开始往回搜索。当 find
完成时,如果列表中有逗号,那么 rcomma
指向其最后一个逗号,即指向反向搜索找到的第一个逗号。如果没有逗号,则 rcomma
的值为 line.rend()
。
在尝试输出所找到的单词时,有趣的事情发生了。直接尝试:
// wrong: will generate the word in reverse order
cout << string(line.rbegin(), rcomma) << endl;
会产生假的输出。例如,如果输入是:FIRST,MIDDLE,LAST
,则将输出 TSAL
!
分析:使用反向迭代器时,以逆序从后向前处理 string
对象。为了得到正确的输出,必须将反向迭代器 line.rbegin()
和 rcomma
转换为从前向后移动的普通迭代器。其实没必要转换 line.rbegin()
,因为我们知道转换的结果必定是 line.end()
。只需调用所有反向迭代器类型都提供的成员函数 base
转换 rcomma
即可:
// ok: get a forward iterator and read to end of line
cout << string(rcomma.base(), line.end()) << endl;
假设还是前面给出的输入,该语句将如愿输出: LAST
。
上图直观地解释了普通迭代器与反向迭代器之间的关系。例如,正如 line_rbegin()
和 line.end()
一样,rcomma
和 rcomma.base()
也指向不同的元素。为了确保正向和反向处理元素的范围相同,这些区别是必要的。从技术上来说,设计普通迭代器与反向迭代器之间的关系是为了适应左闭合范围这个性质,所以,[line.rbegin(), rcomma)
和[rcomma.base(), line.end())
标记的是 line
中的相同元素。
反向迭代器用于表示范围,而所表示的范围是不对称的,这个事实可推导出一个重要的结论:使用普通的迭代器对反向迭代器进行初始化或赋值时,所得到的迭代器并不是指向原迭代器所指向的元素。
三、reverse_iterator的base()函数
1. 示例:
举个例子,看一下这段代码,我们首先把从数字1-5放进一个vector
中,然后产生一个指向3的reverse_iterator
,并且通过reverse_iterator
的base
初始化一个iterator
:
vector<int> v;
v.reserve(5);
for(int i = 1;i <= 5; ++ i) { // 向vector插入1到5v.push_back(i);
}
vector<int>::reverse_iterator ri = find(v.rbegin(), v.rend(), 3);
vector<int>::iterator i(ri.base()); // 使i和ri的base一样
执行上述代码后,可以想到产生的结果就像这样:
这张图很好地显示了reverse_iterator
和它对应的base iterator
之间特有的偏移量,就像rbegin()
和rend()
与相关的begin()
和end()
一样,但并没有说出了所有你需要知道的东西。特别是,它并没有解释怎样在ri
上实现你在i
上想要完成的操作。有些容器的成员函数只接受iterator
类型的参数,所以如果你想要在ri
所指的位置插入一个新元素,你不能直接这么做,因为vector
的insert
函数不接受reverse_iterator
。如果你想要删除ri
所指位置上的元素也会有同样的问题。erase
成员函数会拒绝reverse_iterator
,坚持要求iterator
。为了完成删除和一些形式的插入操作,你必须先通过base
函数将reverse_iterator
转换成iterator
,然后用iterator
来完成工作。
2. 插入元素:
先让我们假设你要在ri
指出的位置上把一个新元素插入v
。特别的,我们假设你要插入的值是99
。记住ri
在上图中遍历的顺序是自右向左,而且插入操作会将新元素插入到ri
位置,并且将原先ri
位置的元素移到遍历过程的"下一个"位置,我们认为3
应该出现在99
的左侧。插入操作之后,v
看起来像这样:
当然,我们不能用ri
来指定插入的地方,因为它不是一个iterator
。我们必须用i
来代替。如上所述,当ri
指向3
时,i
(就是ri.base()
)指向4
。如果我们用ri
来指定插入位置,那么用i
指向插入位置,那个假设就是正确的。结论呢?
要实现在一个reverse_iterator ri
指出的位置上插入新元素,在ri.base()
指向的位置插入就行了。对于insert
操作而言,ri
和ri.base()
是等价的,而且ri.base()
真的是ri
对应的iterator
。
3. 删除元素:
现在再来考虑删除元素的情况。回顾一下最初的vector
(也就是在插入99
之前)ri
与i
的关系:
如果你要删除ri
指向的元素,你不能直接使用i
了,因为i
与ri
不是指向同一个元素。因此,你要删除的是i
的前一个元素。要实现在一个reverse_iterator ri
指出的位置上删除元素,就应该删除ri.base()
的前一个元素。对于删除操作而言,ri
和ri.base()
并不等价,而且ri.base()
不是ri
对应的iterator
。我们还是有必要看看删除操作的代码,因为它还挺令人惊讶的。
vector<int> v;// 向v插入1到5,同上
vecot<int>::reverse_iterator ri =
find(v.rbegin(), v.rend(), 3); // 同上,ri指向3
v.erase(--ri.base()); // 尝试删除ri.base()前面的元素;对于vector,一般来说编译不通过
这个设计并不存在什么问题。表达式--ri.base()
确实能够指出我们需要删除的元素。而且,它们能够处理除了vector
和string
之外的其他所有容器,它可能也能处理vector
和string
,但对于大多数vector
和string
的实现,它无法处理。在这样的实现下,iterator
(和const_iterator
)会采用内建的指针来实现,所以ri.base()
的结果是一个指针。C和C++都规定了不能直接修改函数返回的指针,所以在string
和vector
的迭代器是指针的STL平台上,像--ri.base()
这样的表达式无法通过编译。要移植从一个由reverse_iterator
指出的位置删除元素时,你应该尽量避免修改base
的返回值。没问题。如果你不能减少调用base
的返回值,只需要先增加reverse_iterator
的值,然后再调用base
。
// 同上
v.erase((++ri).base()); // 删除ri指向的元素;
// 这下编译没问题了!
因为这个方法适用于所有的标准容器,这是删除一个由reverse_iterator
指出的元素时首选的技巧。
现在已经很清楚了,reverse_iterator
的base
成员函数返回一个"对应的"iterator
的说法并不准确。对于插入操作而言,的确如此;但是对于删除操作,并非如此。当需要把reverse_iterator
转换成iterator
的时候,有一点非常重要的是你必须知道你准备怎么处理返回的iterator
,因为只有这样你才能决定你得到的iterator
是否是你需要的。
【C++】迭代器、反向迭代器详解相关推荐
- C++ - const 与 迭代器(iterator) 使用 详解
const 与 迭代器(iterator) 使用 详解 本文地址: http://blog.csdn.net/caroline_wendy/article/details/16030561 迭代器(i ...
- LSTM反向传播详解(完结篇)Part3/3代码实现
1.前记 LSTM系列的前面两篇文章<LSTM反向传播详解Part1><LSTM反向传播详解Part2>将LSTM的理论梳理了一遍,本文主要着重用代码实现LSTM,其实也是 ...
- [js高手之路] es6系列教程 - 迭代器与生成器详解
什么是迭代器? 迭代器是一种特殊对象,这种对象具有以下特点: 1,所有对象都有一个next方法 2,每次调用next方法,都会返回一个对象,该对象包含两个属性,一个是value, 表示下一个将要返回的 ...
- js中的迭代器与生成器(详解)
目录 一,迭代器 1.迭代器概念 2.迭代器的基本应用 3.迭代器原理 4.应用:自定义遍历数据 二,生成器 1.生成器概念 2.生成器的基本应用 3.yield表达式的值 4.应用:模拟获取数据 三 ...
- C++:迭代器(STL迭代器)iterator详解
STL迭代器 参考链接:http://c.biancheng.net/view/338.html
- python全栈之巅_Python 迭代器、生成器详解 - Python全栈之巅
迭代器 迭代器是访问集合元素的一种方式.迭代器对象从集合的第一个元素开始访问,知道所有的元素被访问完结束.迭代器只能往前不会后退,不过这也没什么,因为人们很少在迭代途中往后退. 使用迭代器的优点 对于 ...
- Python迭代器和生成器详解(包括yield详解)
文章目录 一.迭代器 1. 可迭代对象(Iterable) 2. 迭代器对象(Iterator) 3. for 循环原理 4. 迭代器的优缺点 二.生成器 1. yield 原理 2. yield 和 ...
- 三种代理服务器以及反向代理详解
1.标准代理服务器(Standard Proxy Cache) 一个标准的代理缓存通常是用来在本地网络的一台机器上存储静态的Web页面的(html ,image).当这个页面被再次请求时,浏览器将从本 ...
- 【神经网络】FNN——前馈神经网络、前向传播、反向传播详解
FNN网络结构: (1)FNN可以理解为多层感知机,即:包含多个隐藏层的神经网络 (2)层与层之间是全连接的,即:相邻两层的任意两个节点都有连接 FNN前向传播: (1)每个神经元以上一层各个节点输出 ...
- [内核内存] 反向映射详解
文章目录 1 匿名页反向映射 1.1 匿名页反向映射关键数据结构 1.2 linux匿名页的反向映射机制 1.3 进程创建时反向映射相关结构体间的关系 1.4 linux为匿名页的VMA分配AV的流程 ...
最新文章
- GitHub超4.4k星:程序员求职,一个算法模板就够了
- 谷歌、亚马逊、微软、IBM…这些巨头都已如何通过AI赚到钱了?
- [转]Framework源码查看
- 实验:3*3卷积核10分类9*9图片卷积核数量最优值
- UpdatePanel Repeater内LinkButton造成页面刷新问题
- 当执行进程ctrl+c关闭不了的时候的解决方法
- Pokemon Go将在日本发布 网络安全公司呼吁防范虚假软件
- 浮点型数据类型存储空间大小(信息学奥赛一本通-T1017)
- 转《js闭包与内存泄漏》
- TrainingModel(3)
- 一种动态阈值白平衡算法实现
- python求一元二次方程的虚数根_一元二次方程虚数根的求解
- 页面风格设定参考——色彩及其效
- 超级爆笑小学生作文大全,这孩子太搞了
- 借京东图文识别baseline 来看clip训练过程。 clip是怎样练成的 。
- 免费申请Jetbrains的产品
- QT二进制流方式读写文件
- 【AI达人创造营第二期】基于Jetson nano的餐厅自助结账系统部署
- [时间序列分析][4]--AR模型,MA模型,ARMA模型介绍
- java中的数据结构——树
热门文章
- .Net使用163smtp发送邮件时错误:邮箱不可用. has no permission解决方法
- jQuery动画练习
- 可信计算的功能与技术
- AHOI2019N省联考凉凉记
- CentOS7 安装WPS: libGLU.so.1()
- pytorch神经网络对Excel数据集进行处理2.0(读取,转为tensor格式,归一化),并且以鸢尾花(iris)数据集为例,实现BP神经网络
- 作为后起之秀的远程控制软件·ToDesk,你安排了没?
- springBoot的过滤器,监听器,拦截器
- 通讯桥接器NET30-FX在三菱编程软件GX Works2中的应用
- liferay的几个配置