【C++】反向迭代器的实现

已于 2023-05-03 16:30:12 修改
阅读量139 收藏
点赞数
文章标签： c++
于 2023-04-09 21:03:30 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/KL4180/article/details/130046160
版权

 反向迭代器的概念：

反向迭代器是一种特殊的迭代器，它与正向迭代器正好相反，正向迭代器从头向尾遍历，而反向迭代器是从尾到头遍历；至于正向迭代器的具体实现方法，我之前已经写过，在此不做赘述，如有需要请阅读这一篇博客：http://t.csdn.cn/7BRwC

由反向迭代器与正向迭代器的性质可知：

正向迭代器的++ =反向迭代器的-- ；

正向迭代器的-- =反向迭代器的++ ；

，但是，不是所有的容器都支持正向迭代器与反向迭代器，有的容器支持双向迭代，有的不支持，所以迭代器有大致分为五种（输出迭代器/输入迭代器/向前迭代器/双向迭代器/随机访问迭代器），这里，我们以支持双向迭代的list类为例，来实现反向迭代器；

这里我们可以先看一下list正向迭代器的实现方式，具体代码如下所示：


	//增加模板参数ref，解决const迭代器的问题；   
	//增加模板参数ptr，解决自定义类型结构体的->问题；
	template <class T,class ref,class ptr>
	struct list_iterator
	{
		typedef list_node<T> node;//生成结点，
		typedef list_iterator<T,ref,ptr> self;//typedef 重定义名称，增强其可读性；

		node* _node;//迭代器内需要一个节点，来实现移动以及取值；
		list_iterator(node* node)//迭代器需要结点来实现迭代；
			:_node(node)
		{
		}

		ref operator*()
		{
			return _node->data;
		}

		ptr operator->()
		{
			return &_node->data;
		}

		self& operator++()
		{
			_node = _node->_next;//++是指向下一个结点
			return *this;
		}

		self operator++(int)
		{
			self temp(*this);
			_node = _node->_next;
			return temp;
		}

		self& operator--()
		{
			_node = _node->_prev;
			return *this;
		}

		self operator--(int) //--是指向上一个结点
		{
			self temp(*this);
			_node = _node->_prev;
			return temp;
		}
		bool operator!=(const self& LL)
		{
			return _node != LL._node;
		}

		bool operator==(const self& LL)
		{
			return _node == LL._node;
		}
	};

    template <class T>
	class List
	{
		typedef list_node<T> node;
	public:
		typedef list_iterator<T, T&, T*> iterator;//普通迭代器；
		typedef list_iterator<T, const T&, const T*> const_iterator;//const迭代器，可以修改迭代器，但是不能修改迭代器所指向的内容；

         //正向迭代器
		iterator begin()
		{
			return iterator(_phead->_next);
		}

		iterator end()
		{
			return iterator(_phead);
		}
        
        //const正向迭代器：
		const_iterator begin()const
		{
			return const_iterator(_phead->_next);
		}

		const_iterator end()const
		{
			return const_iterator(_phead);
		}

		private:
			node* _phead;
	};

我们知道，正向迭代器与反向迭代器的++/--是倒过来的，那么什么只需要在list类上的正向迭代器上做稍微的改动就基本上就能实现出反向迭代器，只需要把正向迭代器中的指向下一个结点改为指向上一个结点就实现出反向迭代器，具体代码如下所示：


	//增加模板参数ref，解决const迭代器的问题；   
	//增加模板参数ptr，解决自定义类型结构体的->问题；
	template <class T,class ref,class ptr>
	struct list_iterator//正向迭代器：
	{
		typedef list_node<T> node;//生成结点，
		typedef list_iterator<T,ref,ptr> self;//typedef 重定义名称，增强其可读性；

		node* _node;//迭代器内需要一个节点，来实现移动以及取值；
		list_iterator(node* node)//迭代器需要结点来实现迭代；
			:_node(node)
		{
		}

		ref operator*()
		{
			return _node->data;
		}

		ptr operator->()
		{
			return &_node->data;
		}

		self& operator++()
		{
			_node = _node->_next;
			return *this;
		}

		self operator++(int)
		{
			self temp(*this);
			_node = _node->_next;
			return temp;
		}

		self& operator--()
		{
			_node = _node->_prev;
			return *this;
		}

		self operator--(int)
		{
			self temp(*this);
			_node = _node->_prev;
			return temp;
		}
		bool operator!=(const self& LL)
		{
			return _node != LL._node;
		}

		bool operator==(const self& LL)
		{
			return _node == LL._node;
		}
	};


    //改造正向迭代器变成反向迭代器：
	 //不适用于其他容器，list可以通过改写正向迭代器逆推反向迭代器。但是如vector则无法逆推！
	template <class T, class ref, class ptr>
	struct reverse_iterator
	{
		typedef list_node<T> node;
		typedef reverse_iterator<T, ref, ptr> self;

		node* _node;//迭代器内需要一个节点，来实现移动以及取值；
		reverse_iterator(node* node)
			:_node(node)
		{
		}

		ref operator*()
		{
			return _node->data;
		}

		ptr operator->()
		{
			return &_node->data;
		}

		self& operator++()
		{
			_node = _node->_prev;//++是指向上一个结点
			return *this;
		}

		self operator++(int)
		{
			self temp(*this);
			_node = _node->_prev;
			return temp;
		}

		self& operator--()//-- 是指向下一个结点
		{
			_node = _node->_next;
			return *this;
		}

		self operator--(int)
		{
			self temp(*this);
			_node = _node->_next;
			return temp;
		}
		bool operator!=(const self& LL)
		{
			return _node != LL._node;
		}

		bool operator==(const self& LL)
		{
			return _node == LL._node;
		}
	};

    template <class T>
	class List
	{
		typedef list_node<T> node;
	public:
		typedef list_iterator<T, T&, T*> iterator;//普通迭代器；
		typedef list_iterator<T, const T&, const T*> const_iterator;//const迭代器，可以修改迭代器，但是不能修改迭代器所指向的内容；


		//typedef reverse_Iterator<T, T&, T*> reverse_iterator;//通过正向迭代器逆推反向迭代器;
		//typedef reverse_Iterator<T, T&, T*> const_reverse_iterator;//const反向迭代器;

         //正向迭代器
		iterator begin()
		{
			return iterator(_phead->_next);
		}

		iterator end()
		{
			return iterator(_phead);
		}
        
        //const正向迭代器：
		const_iterator begin()const
		{
			return const_iterator(_phead->_next);
		}

		const_iterator end()const
		{
			return const_iterator(_phead);
		}


		通过正向迭代器逆推反向迭代器：
		reverse_iterator rbegin()
		{
			return reverse_iterator(_phead->_prev);
		}
		reverse_iterator rend()
		{
			return reverse_iterator(_phead);
		}

		通过正向迭代器逆推反向迭代器（const反向迭代器）：
		const_reverse_iterator rbegin()const
		{
			return const_reverse_iterator(_phead->_prev);
		}
		const_reverse_iterator rend()const
		{
			return const_reverse_iterator(_phead);
		}

		private:
			node* _phead;
	};

通过上述代码我们可知，虽然可以通过正向迭代器逆推出反向迭代器，但是只是改变了迭代器++，--所指向的结点，同时因为这是list类，是双向循环链式结构，不具有普适性，为了应对代码冗余与不具有普适性两大缺点，我们必须舍弃这种修改正向迭代器的做法

//////

 通过对STL库反向迭代器源码的学习，我们可以将正向迭代器封装来实现反向迭代器，就像通过适配器模式用 顺序表，链表来实现 数组栈 / 链式栈 / 队列一样，我们通过正向迭代器来实现反向迭代器，同时，我们发现源码中operator*的实现有一丝丝的奇怪，operator*不再解引用当前迭代器

所指向的元素；

 为了解决operator*的问题，我们需要明白begin(),end(),rbegin(),rend()的位置；通过源码的描述，画出大致位置图（以list类为例）：

 

 我们可以发现STL库中将正向迭代器的begin(),end(),与反向迭代器的rbegin(),rend()设计成正好相反的样子，可能是为了追求“对称美”，那么，为了解决在 rbegin() 处解引用的问题，

所以将operator*改为解引用上一个结点；

总结出：

正向迭代器的operator*:解引用当前迭代器所指向的元素；

反向迭代器的operator*:解引用当前迭代器所指向的前一个元素；

具体代码如下所示：

	//增加模板参数ref，解决const迭代器的问题；   
	//增加模板参数ptr，解决自定义类型结构体的->问题；
	template <class T,class ref,class ptr>
	struct list_iterator//正向迭代器：
	{
		typedef list_node<T> node;//生成结点，
		typedef list_iterator<T,ref,ptr> self;//typedef 重定义名称，增强其可读性；

		node* _node;//迭代器内需要一个节点，来实现移动以及取值；
		list_iterator(node* node)//迭代器需要结点来实现迭代；
			:_node(node)
		{
		}

		ref operator*()
		{
			return _node->data;
		}

		ptr operator->()
		{
			return &_node->data;
		}

		self& operator++()
		{
			_node = _node->_next;
			return *this;
		}

		self operator++(int)
		{
			self temp(*this);
			_node = _node->_next;
			return temp;
		}

		self& operator--()
		{
			_node = _node->_prev;
			return *this;
		}

		self operator--(int)
		{
			self temp(*this);
			_node = _node->_prev;
			return temp;
		}
		bool operator!=(const self& LL)
		{
			return _node != LL._node;
		}

		bool operator==(const self& LL)
		{
			return _node == LL._node;
		}
	};


	//封装正向迭代器，来实现反向迭代器，
	//适用于所有的容器。泛型模板，只要这个容器是可双向迭代的，都可以使用封装正向迭代器来实现反向迭代器；
	template<class Iterator,class Ref,class ptr>//封装正向迭代器
	struct reverse_Iterator
	{
		typedef reverse_Iterator<Iterator,Ref,ptr> self;
		Iterator _cur;
		reverse_Iterator(Iterator it)
			:_cur(it)
		{
		}

		Ref operator*()//解引用当前迭代器所指向的前一个元素；
		{
			Iterator temp = _cur;
			--temp;
			return *temp;
		}

		ptr operator->()
		{
			Iterator temp =_cur;
			--temp;
			return &(*temp);
		}

		self& operator++()//++就是指向前一个元素；
		{
			--_cur;
			return *this;
		}

		self operator++(int)
		{
			Iterator temp = _cur;
			--_cur;
			return temp;
		}

		self& operator--()//--就是指向后一个元素；
		{
			++_cur;
			return *this;
		}

		self operator--(int)
		{
			iterator temp = _cur;
			++_cur;
			return temp;
		}

		bool operator!=(const self& LL)
		{
			return _cur != LL._cur;
		}

		bool operator==(const self& LL)
		{
			return _cur == LL._cur;
		}
	};


	template <class T>
	class List
	{
		typedef list_node<T> node;
	public:
		typedef list_iterator<T, T&, T*> iterator;//普通迭代器；
		typedef list_iterator<T, const T&, const T*> const_iterator;//const迭代器，可以修改迭代器，但是不能修改迭代器所指向的内容；


		typedef reverse_Iterator<iterator, T&, T*> reverse_iterator;//通过封装正向迭代器来实现反向迭代器；
		typedef reverse_Iterator <iterator, const T&, const T*> const_reverse_iterator;//const反向迭代器；

        
        //正向迭代器：
		iterator begin()
		{
			return iterator(_phead->_next);
		}

		iterator end()
		{
			return iterator(_phead);
		}

        //const正向迭代器
		const_iterator begin()const
		{
			return const_iterator(_phead->_next);
		}

		const_iterator end()const
		{
			return const_iterator(_phead);
		}

        
        //反向迭代器：
		reverse_iterator rbegin()
		{
			return reverse_iterator(end());
		}

		reverse_iterator rend()
		{
			return reverse_iterator(begin());
		}
        

        //const反向迭代器：
		const_reverse_iterator rbegin()const
		{
			return const_reverse_iterator(end());
		}

		const_reverse_iterator rend()const
		{
			return const_reverse_iterator(begin());
		}



		private:
			node* _phead;
	};

写到这里，反向迭代器基本上已经实现，但是给人感觉和我们改动正向迭代器逆推反向迭代器差不多，代码也有冗余，那么封装正向迭代器的意义在什么地方呢？

封装正向迭代器实现反向迭代器的巨大优点是：只要这个容器支持双向迭代遍历，那么都可以通过封装正向迭代器实现反向迭代器，而改动正向迭代器逆推反向迭代器不一定能实现出来，比如vector等；

KL4180
关注
C++反向迭代器的原理+模拟实现+萃取
qq_53413129的博客
03-27 426
反向迭代器实际上就是在正向迭代器的基础上将其转换一下就变成了反向的，里面会传一个迭代器模板，这个模板随便是谁的迭代器模板，可以是list的，vector的等等，其只要有一个模板，引用了正向迭代器，其他SLT类型都可以用这个反向迭代器，这也是类型的力量，泛型就是这么强大。 ...
初识C++之模拟实现stack、queue和反向迭代器
Masquerena114514的博客
03-12 560
讲解了stl库中的stack和queue的模拟实现、适配器模式、双端队列及反向迭代器的实现和仿函数的概念
【C++】反向迭代器
在平淡的日子里寻找存在的价值
03-08 1627
C++ 反向迭代器的实现
反向迭代器
wjmhlh的博客
01-29 606
在官方库中，反向迭代器是使用适配器封装的，即用普通的迭代器去作为适配器，然后封装出一个反向迭代器出来。
C/C++编程：浅谈reverse_iterator的base()函数
OceanStar的博客
09-17 1970
API std::reverse_iterator<Iter>::base 从其 reverse_iterator还原基础迭代器。 iterator_type base() const; (until C++17) constexpr iterator_type base() const; (since C++17) 与其基础迭代器处理所有反向迭代器的标识是： &*(rit
C++迭代器适配器:反向迭代器、插入迭代器、iostream迭代器
qq_40586164的博客
08-13 478
适配器是标准库中的一个通用概念。容器、迭代器和函数都有适配器(C++11出现了lambda函数、function类模板、bind函数，几乎取代了函数适配器)。本质上，适配器是一种机制，能使某种事物的行为看起来像另外一种一样。栈、队列、优先队列都属于容器适配器。本文主要介绍迭代器适配器。 迭代器适配器主要有三类：逆向迭代器，插入迭代器，流类迭代器。 插入迭代器 插入迭代器有三种类型，差异在于元素插入的位置： back_inserter( Container& c )，在容器尾部插入，只能对有push
C++11迭代器专栏详解
qq_43923676的博客
12-04 996
c++迭代器详解迭代器介绍使用迭代器迭代器运算符迭代器类型迭代器运算chapter 9迭代器再探迭代器插入迭代器iostream迭代器反向迭代器五类迭代器 迭代器介绍 迭代器可以使用下标运算符来访问string对象的字符或vector对象的元素，所有标准库容器都可以使用迭代器，但是其中只有少数的几种菜同时支持下标运算，类似于指针类型，迭代器也提供了对对象的间接访问。就迭代器而言，其对象是容器中的元素或者string中的字符，使用迭代器可以访问某个元素，迭代器也能从一个元素移动到另一个元素。迭代器有有效和无效
C++STL迭代器
ProgramAlcohol的博客
12-30 377
迭代器 1.迭代器：类中类，通过运算符的重载，用类中类的对象遍历容器 2.迭代器分类： （1）正向迭代器：iterator（begin(); end();） （2）反向迭代器：reverse_iterator（rbegin(); rend();） （3）常正向迭代器：const_iterator（cbegin(); cend();） （4）常反向迭代器：const_reverse_iterator（crbegin(); crend();） 3.按功能分类： （1）正向迭代器 （2）双向迭代
C++迭代器之'反向迭代器'
BonChoix的专栏
10-11 6510
反向迭代器(Reverse Iterator)是普通迭代器的适配器，通过重新定义自增和自减操作，以达到按反序遍历元素的目的。如果在标准算法库中用反向迭代器来代替普通的迭代器，那么运行结果与正常情况下相反。除此之外，其用法与普通迭代器完全一样，我们不作详细讨论。        这里主要讨论的是反向迭代器的一个很特殊、也很容易出错的性质，即它的“逻辑位置”与“物理位置”。先通过看一个例子开始： v
C++ set用法以及迭代器用法
weixin_30585437的博客
01-16 3724
有关set的一些常用函数 1.begin() / end() 返回首/尾元素迭代器 2.rbegin() / rend() 返回尾/首元素反向迭代器，反向迭代器可以反向遍历容器的迭代器，从下面的程序已经可以看出，正常的迭代器++为顺序遍历，而反向迭代器的效果就是反向迭代器++后，可倒序遍历容器(--则相反)。 3.支持用 '=' 赋值 4.empty() 当前set是否为空 5...
C++ 反向迭代器注意事项
Leo
01-13 762
C++ 反向迭代器注意事项
反向迭代器（rbegin,rend）
热门推荐
kjing的专栏
11-04 12万+
C++ primer （中文版第四版）第273页 9.3.2 begin和end成员         begin和end操作产生指向容器内第一个元素和最后一个元素的下一个位置的迭代器，如下所示。这两个迭代器通常用于标记包含容器中所有元素的迭代范围。 c.begin() 返回一个迭代器，它指向容器c的第一个元素 c.end() 返回一个迭代器，它指向容器c的最后一个元素的下一个位置 c.r
【C++】迭代器、反向迭代器详解
lemonxiaoxiao的博客
11-16 5412
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）”进行。迭代器是一个变量，相当于容器和操纵容器的算法之间的中介。迭代器可以指向容器中的某个元素，通过迭代器就可以读..
C语言 12 函数
天河有尽后为涯，星海无边前作岸。
09-13 1114
程序的入口点就是main函数，只需要将程序代码编写到主函数中就可以运行了，不过这个函数只是由我们来定义，而不是我们来调用。当然，除了主函数之外，一直在使用的printf那么，函数的具体定义是什么呢？函数是完成特定任务的独立程序代码单元。每次要做这个任务时，都要完完整整地将任务的每一行代码都写下来，如果程序中多处都需要执行这个任务，每个地方都完整地写一遍，实在是太臃肿了，有没有一种更好的办法能优化代码呢？
CF C. Nikita and LCM
最新发布
qq_74190237的博客
09-13 281
思维题.首先先对数组排序,考虑一种特殊情况,那就是如果数组最大值不能被其他数整除,这代表什么?代表其他数里面有某个质因子,最大值里面没有或者数量不管,所有最小公倍数都会大于最大值.那么其他情况的话,就可以确定所有的数都是最大数的因子,那么形成的最小公倍数也一定是最大数的因子,那么就可以枚举一下最大数的因子,就可以了.给长度为n的数组,求出最长的特殊子数组,如果子数组的最小公倍数不在原数组中,那么就是特殊的.
C++与QML的数据交互
qq_50679120的博客
09-11 536
这里没什么好说的，在C++中组合好json后，通过信号发送到qml中，qml中是可以解析json的。通过Q_PROPERTY属性，可以轻松地在QML中读取和修改数据，并将其更新到C++中，先创建一个类。在QML接收，直接通过data.can_id这样的形式去访问结构体中的元素。这两个也没什么好说的，在C++中直接发送信号就好了，在C++中声明并注册一个结构体。然后发送信号到QML中。
c++set反向迭代器
07-28
C++的`std::set`是一个有序的容器，它不支持直接的反向迭代器。然而，你可以使用`std::set`的`rbegin()`和`rend()`成员函数来获取反向迭代器，从而实现反向遍历。 这里是一个简单的示例代码，展示了如何使用反向...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值