【STL】：反向迭代器

已于 2023-11-19 14:44:03 修改
阅读量326 收藏 1
点赞数 3
分类专栏： C++ 文章标签： c++ 开发语言 反向迭代器
于 2023-11-19 14:42:40 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Yikefore/article/details/134217776
版权

朋友们、伙计们，我们又见面了，本期来给大家解读一下有关反向迭代器的模拟实现，如果看完之后对你有一定的启发，那么请留下你的三连，祝大家心想事成！

C 语 言 专 栏：C语言：从入门到精通

数据结构专栏：数据结构

个  人  主  页 ：stackY、

C + + 专 栏   ：C++

Linux 专 栏  ：Linux

​

目录

前言：

1. 基本构造

2. 接口完善

3. 在list中使用反向迭代器

list反向迭代器版本一：

list反向迭代器版本二： 

4. 在vector中使用反向迭代器 

前言：

前面的模拟实现vector和list中是没有实现反向迭代器的，反向迭代器与正向迭代器相比就是从数据的末端向前面访问遍历，但是两个迭代器的用法都是一样的，++就是下一个，*就可以访问到数据，但是它具体是怎么实现的呢？我们接下来看一看：

1. 基本构造

在list的模拟实现中讲解了如何实现正向迭代器（包含const版本和非const版本）那么在本期实现反向迭代器的时候就有了一定的前车之鉴，比如const版本和非const版本不需要实现两份代码，可以采用模板实现泛型编程。

反向迭代器的构造可以使用正向迭代器来进行复用，因为反向迭代器的++就是正向迭代器里面的--，所以在传递模板参数的时候可以直接传递一个迭代器，直接复用这个迭代器里面的各种结构完成反向迭代器的构造。这种方式叫做迭代器适配器。

#pragma once

namespace ywh
{
	//反向迭代器
	template <class Iterator, class Ref, class Ptr>
	class ReverseIterator
	{
	public:
		typedef ReverseIterator<Iterator, Ref, Ptr> Self;

		//构造
		ReverseIterator(Iterator it)
			:_it(it)
		{}

	private:
		Iterator _it;
	};
}

2. 接口完善

反向迭代器的接口有++、--、*、->、!=、==，这些接口的实现都是可以通过使用模板参数中的迭代器来进行复用即可。

头文件： reverse_iterator.h

#pragma once

namespace ywh
{
	//反向迭代器
	template <class Iterator, class Ref, class Ptr>
	class ReverseIterator
	{
	public:
		typedef ReverseIterator<Iterator, Ref, Ptr> Self;

		//构造
		ReverseIterator(Iterator it)
			:_it(it)
		{}

		//前置
		//operator++
		Self& operator++()
		{
			//复用传过来的迭代器里面的operator--
			--_it;
			return *this;
		}
		//operator--
		Self&operator++()
		{
			++_it;
			return *this;
		}

		//operator*
		Ref operator*()
		{
			return *_it;
		}
		//operator->
		Ptr operator->()
		{
			return _it.operator->();
		}

		//operator==
		bool operator==(const Self& s)
		{
			return _it == s._it;
		}
		//operator!=
		bool operator!=(const Self& s)
		{
			return _it != s._it;
		}
	private:
		Iterator _it;
	};
}

3. 在list中使用反向迭代器

要使用反向迭代器，首先得在list头文件中包含以下反向迭代器的头文件，然后进行构造：

list反向迭代器版本一：

#pragma once
#include "reverse_iterator.h"
namespace ywh
{
	//链表结构
	template<class T>
	struct list_node
	{
		T _data;                 //节点中的数据
		list_node<T>* _prev;    //指向前一个节点的指针
		list_node<T>* _next;    //指向后一个节点的指针

		//构造
		list_node(const T& x = T())
			:_data(x)
			, _prev(nullptr)
			, _next(nullptr)
		{}

	};

	//正向迭代器
	//   类型模板参数   传递引用      传递指针
	template<class T, class Ref, class Ptr>
	struct __list_iterator
	{
		typedef list_node<T> Node;
		typedef __list_iterator<T, Ref, Ptr> self;
		Node* _node;
		//迭代器构造
		__list_iterator(Node* node)
			:_node(node)
		{}
		
		//前置
		//operator++
		self& operator++()
		{
			_node = _node->_next;
			return *this;
		}
		//operator--
		self& operator--()
		{
			_node = _node->_prev;
			return *this;
		}

		//后置
		self operator++(int)
		{
			self* tmp(_node);
			_node = _node->_next;
			return tmp;
		}
		//operator--
		self operator--(int)
		{
			self* tmp(_node);
			_node = _node->_prev;
			return tmp;
		}

		//operator*
		Ref operator*()
		{
			return _node->_data;
		}
		//operator->
		Ptr operator->()
		{
			return &_node->_data;
		}
		//operator!=
		bool operator!=(const self& s)
		{
			return _node != s._node;
		}
		//operator==
		bool operator==(const self& s)
		{
			return _node == s._node;
		}
	};

	//list结构
	template<class T>
	class list
	{
	public:
		typedef list_node<T> Node;
		typedef __list_iterator<T, T&, T*> iterator;   //非const迭代器
		typedef __list_iterator<T, const T&, const T*> const_iterator;  //const迭代器
		typedef ReverseIterator<iterator, T&, T*> reverse_iterator;   //反向迭代器
		typedef ReverseIterator<const_iterator, const T&, const T*> const_reverse_iterator;   //反向迭代器

	public:
		基本构造///
		//...
		///正向迭代器
		iterator begin()
		{
			return iterator(_head->_next); //使用匿名对象进行构造
		}
		iterator end()
		{
			return iterator(_head);
		}
		const_iterator begin() const
		{
			return const_iterator(_head->_next);
		}
		const_iterator end() const
		{
			return const_iterator(_head);
		}
		//反向迭代器/
		reverse_iterator rbegin()
		{
			return reverse_iterator(--end());
		}
		reverse_iterator rend()
		{
			return reverse_iterator(end());
		}
		const_reverse_iterator rbegin() const
		{
			return const_reverse_iterator(--end());
		}
		const_reverse_iterator rend() const
		{
			return const_reverse_iterator(end());
		}
		///修改相关接口
		//...
	private:
		Node* _head;  //链表的头节点
		size_t _size; //节点个数
	};
}

list反向迭代器版本二： 

我们也可以看一下库里面list的反向迭代器如何设计：

可以看到库里面的玩法是一种对称的结构，这种对称的结构在解引用访问时访问的是下一个节点的元素，这样子写是比较好理解的，正向的起始就是反向的结束，正向的结束就是反向的起始，那么我们也可以来按照这种写法来写一下：

头文件：reverse_iterator.h

#pragma once
namespace ywh
{
	//反向迭代器
	template <class Iterator, class Ref, class Ptr>
	class ReverseIterator
	{
	public:
		typedef ReverseIterator<Iterator, Ref, Ptr> Self;

		//构造
		ReverseIterator(Iterator it)
			:_it(it)
		{}

		//前置
		//operator++
		Self& operator++()
		{
			//复用传过来的迭代器里面的operator--
			--_it;
			return *this;
		}
		//operator--
		Self&operator++()
		{
			++_it;
			return *this;
		}

		//operator*
		Ref operator*()
		{
			Iterator cur = _it;
			//返回下一个节点的数据
			return *(--cur);
		}
		//operator->
		Ptr operator->()
		{
			return _it.operator->();
		}

		//operator==
		bool operator==(const Self& s)
		{
			return _it == s._it;
		}
		//operator!=
		bool operator!=(const Self& s)
		{
			return _it != s._it;
		}
	private:
		Iterator _it;
	};
}

头文件：List.h

#pragma once
#include "reverse_iterator.h"
namespace ywh
{
	//链表结构
	template<class T>
	struct list_node
	{
		T _data;                 //节点中的数据
		list_node<T>* _prev;    //指向前一个节点的指针
		list_node<T>* _next;    //指向后一个节点的指针

		//构造
		list_node(const T& x = T())
			:_data(x)
			, _prev(nullptr)
			, _next(nullptr)
		{}

	};

	//正向迭代器
	//   类型模板参数   传递引用      传递指针
	template<class T, class Ref, class Ptr>
	struct __list_iterator
	{
		typedef list_node<T> Node;
		typedef __list_iterator<T, Ref, Ptr> self;
		Node* _node;
		//迭代器构造
		__list_iterator(Node* node)
			:_node(node)
		{}
		
		//前置
		//operator++
		self& operator++()
		{
			_node = _node->_next;
			return *this;
		}
		//operator--
		self& operator--()
		{
			_node = _node->_prev;
			return *this;
		}

		//后置
		self operator++(int)
		{
			self* tmp(_node);
			_node = _node->_next;
			return tmp;
		}
		//operator--
		self operator--(int)
		{
			self* tmp(_node);
			_node = _node->_prev;
			return tmp;
		}

		//operator*
		Ref operator*()
		{
			return _node->_data;
		}
		//operator->
		Ptr operator->()
		{
			return &_node->_data;
		}
		//operator!=
		bool operator!=(const self& s)
		{
			return _node != s._node;
		}
		//operator==
		bool operator==(const self& s)
		{
			return _node == s._node;
		}
	};

	//list结构
	template<class T>
	class list
	{
	public:
		typedef list_node<T> Node;
		typedef __list_iterator<T, T&, T*> iterator;   //非const迭代器
		typedef __list_iterator<T, const T&, const T*> const_iterator;  //const迭代器
		typedef ReverseIterator<iterator, T&, T*> reverse_iterator;   //反向迭代器
		typedef ReverseIterator<const_iterator, const T&, const T*> const_reverse_iterator;   //反向迭代器

	public:
		基本构造///
		//...
		///正向迭代器
		iterator begin()
		{
			return iterator(_head->_next); //使用匿名对象进行构造
		}
		iterator end()
		{
			return iterator(_head);
		}
		const_iterator begin() const
		{
			return const_iterator(_head->_next);
		}
		const_iterator end() const
		{
			return const_iterator(_head);
		}
		//反向迭代器/
		reverse_iterator rbegin()
		{
			return reverse_iterator(end());
		}
		reverse_iterator rend()
		{
			return reverse_iterator(begin());
		}
		const_reverse_iterator rbegin() const
		{
			return const_reverse_iterator(end());
		}
		const_reverse_iterator rend() const
		{
			return const_reverse_iterator(begin());
		}
		///修改相关接口
		//...
	private:
		Node* _head;  //链表的头节点
		size_t _size; //节点个数
	};
}

4. 在vector中使用反向迭代器 

vector中的反向迭代器不建议使用上面的版本一，因为begin()和end()是传值返回，是临时对象，而临时对象具有常性，不好进行修改，所以还是比较建议使用这种对称的结构。

头文件：Vector.h

#pragma once
#include <assert.h>
#include "reverse_iterator.h"
namespace ywh
{
	template<class T>
	class vector
	{
	public:
		typedef T* iterator;
		typedef const T* const_iterator;
		typedef ReverseIterator<iterator, T&, T*> reverse_iterator;
		typedef ReverseIterator<const_iterator, const T&, const T*> const_reverse_iterator;
	public:
		/正向迭代器
		iterator begin()
		{
			return _start;
		}
		iterator end()
		{
			return _finish;
		}
		const_iterator begin() const
		{
			return _start;
		}
		const_iterator end() const
		{
			return _finish;
		}
		/反向迭代器/
		reverse_iterator rbegin()
		{
			return reverse_iterator(end());
		}
		reverse_iterator rend()
		{
			return reverse_iterator(begin());
		}
		const_reverse_iterator rbegin() const
		{
			return const_reverse_iterator(end());
		}
		const_reverse_iterator rend() const
		{
			return const_reverse_iterator(begin());
		}
		/基本构造///
	    //...
		///容量
		//...
		///修改
		//...
	private:
		iterator _start = nullptr;   //起始位置
		iterator _finish = nullptr;  //有效数据位置
		iterator _end_of_storage = nullptr; //结束位置
	};
}

朋友们、伙计们，美好的时光总是短暂的，我们本期的的分享就到此结束，欲知后事如何，请听下回分解~，最后看完别忘了留下你们弥足珍贵的三连喔，感谢大家的支持！   

stackY、
关注
  • 3
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
浅谈c++ stl迭代器失效的问题
08-31
下面小编就为大家带来一篇浅谈c++ stl迭代器失效的问题。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧，祝大家游戏愉快哦
C++ [STL容器反向迭代器]
ARMCSKGT的博客
06-19 6044
我们知道STL大部分容器都有迭代器，迭代器又分为正向迭代器和反向迭代器，对于正向迭代器以及实现前面我们已经了解了不少，而反向迭代器的设计思想是适配器模式，本节我们介绍反向迭代器的实现！本节简单介绍了反向迭代器思想，将类和对象的封装意义体现的淋漓尽致，快来学习吧！
C++【STL】【反向迭代器】
芊樱烛渊的博客
09-28 1313
12345如果是正向迭代器就是从1->2->3->4->5，也就是正向迭代器的++是向右边走但是我们的反向迭代器的++是向左边走，也就是5->4->3->2->1{//正向迭代器{++it;}//反向迭代器{++rit;}}
C++ STL学习之【反向迭代器】
北 海的博客
04-22 4461
适配器模式是STL中的重要组成部分，在上一篇文章中我们学习了容器适配器的相关知识，即stack与queue，除了容器适配器外，还有迭代器适配器，借助迭代器适配器，可以轻松将各种容器中的普通迭代器转变为反向迭代器，这正是适配器的核心思想
【C++】STL——反向迭代器的模拟实现：迭代器适配器
m0_70980326的博客
05-27 1165
反向迭代器的使用相信大家都已经比较熟悉了，那我们这篇文章具体讲什么呢？这篇文章我们重点来讲一下反向迭代器的模拟实现。那为什么我们之前不和正向迭代器放在一块讲呢？为什么要等到我们讲完了容器适配器再来讲反向迭代器的模拟实现呢？那这个问题我相信学完这篇文章大家就明白了。
STL简单迭代器的实现
05-10
介绍博客：http://blog.csdn.net/chengonghao/article/details/51360792
STL迭代器类型
08-15
STL迭代器类型 输入迭代器,输出迭代器,双向迭代器,向前迭代器,随机迭代器...
关于STL的erase()陷阱-迭代器失效问题的总结
08-31
下面小编就为大家带来一篇关于STL的erase()陷阱-迭代器失效问题的总结。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧
理解C语言中的位操作和整数类型：一个温度传感器读取问题的解析
qq_61637982的博客
04-24 260
当我们编写嵌入式系统的代码时，我们经常需要使用位操作来处理硬件设备的数据。然而，如果我们对C语言的位操作和整数类型不完全理解，可能会遇到一些难以理解的问题。在这篇博客中，我将通过一个实际的例子来解释这些概念，并提供一个解决方案。
C++ Primer (第五版）第八章习题部分答案
weixin_48467622的博客
04-27 990
C++ Primer (第五版）第八章习题部分答案
手搓顺序表（C语言）
m0_62646213的博客
04-23 687
顺序表头插头删，尾插尾删，任意位置插入删除的实现和优劣分析
c入门基础题（3）
梦昼初
04-26 880
1、找出数组中最大元素的位置（下标值） 输入 多组测试，每组先输入一个不大于10的整数n 然后是n个整数 输出 输出这n个整数中最大的元素及下标值 样例输入 4 1 4 5 6 样例输出 6 3 #include<stdio.h> int main(){ int a[20]; int n,x=0,y,z,s,m,f; int i,j; while(scanf("%d",&n)!=EOF){ for(i=1;i<=n;i++){ scanf("%d",&y)
(C++) this_thread 函数介绍
cuber-lotus的博客
04-24 1412
在C++11起，标准规定了标注的并发库。头文件为并发支持库 (C++11 起) - cppreference.com其包含线程、原子操作、互斥、条件变量和 future 的内建支持。而其中有一个namespace为，里面有四个重要的全局函数，其实现都与当前系统环境和编译器强绑定。std::this_thread 符号索引 - cppreference.comget_id()yield()返回当前线程的id。这个id是一个的内部类型。其实现依附于所在平台。
C++笔试强训day7
cy18779588218的博客
04-26 437
因为我见了很多DFS的题目返回值都为bool，因此我认为DFS必须以bool作返回值，结果导致浪费很多时间还得不到成果。然后我写代码的时候代码思路没跟上原本思路，直接把所有的l，r，len都存起来，然后最后再遍历一遍存起来的数。回想起才发现思路清晰了，但是代码写的一塌糊涂，其实可以直接在遍历的过程中不断更新l，r，len就可以了。我没有经过思考，所有就把所有情况都遍历了，真的很傻的行为，虽然过了，但是很繁琐嘞，太多情况了。因为是排序过后的，所以只需要遍历包含第一个数在内的四种情况即可。
从C语言到C++过渡篇（快速入门C++）
2302_80023639的博客
04-27 695
C语言->C++的过渡（快速入门C++） 命名空间、C++输入与输出（cout && cin）、缺省参数、函数重载 引用、内联函数、auto 关键字、区别于C语言的空指针（nullptr）
【C++】const修饰输入参数
zjh2883的博客
04-28 161
在这个例子中，printValue函数的参数被声明为const，这意味着函数内部不会修改value的值。如果尝试修改value，编译器将会报错，从而避免了潜在的bug。在C++中，传参时使用const可以防止在函数内部不小心修改了传入的参数，这样可以提高代码的健壮性和可维护性。const表示函数内部不会修改传入的参数。，由于函数将自动产生临时变量用于复制该参数，该输入参数本来就无需保护，所以不要加const修饰。,那么加const修饰可以防止意外地改动该指针，起到保护作用。
【C++】析构函数的作用及其使用
最新发布
原小明
04-28 570
当一个对象的生命周期结束时，无论是对象所在的作用域结束（例如，局部对象在函数退出时）、对象被delete（针对动态分配的对象）、或者容器（如std::vector）自动销毁其元素时，析构函数都会被自动调用。在继承关系中，当派生类的析构函数执行完毕后，基类的析构函数会被自动调用，确保了基类资源的正确释放。同样，如果一个类包含了另一个类的对象作为成员，那么当该类的析构函数被调用时，成员对象的析构函数也会被自动调用，递归地清理整个对象结构。然而，对于管理了资源的类，最好显式定义析构函数以确保资源的正确清理。
C++中把Lambda 表达式作为参数传递给模板函数。
weixin_42944928的博客
04-27 155
【代码】C++中把Lambda 表达式作为参数传递给模板函数。
stllist迭代器
07-28
C++中的STL(List)迭代器是用于遍历和操作链表(List)中元素的一种方式。迭代器可以指向链表中的任意位置，并且可以通过迭代器进行元素的访问、插入、删除等操作。 STL的List迭代器有两种类型：正向迭代器和反向迭代器。正向迭代器用于从链表的头部开始遍历到尾部，而反向迭代器则相反，从尾部开始遍历到头部。 下面是一个使用STL List迭代器的简单示例代码： ```cpp #include <iostream> #include <list> int main() { std::list<int> myList = {1, 2, 3, 4, 5}; // 正向迭代器遍历链表 std::list<int>::iterator it; for (it = myList.begin(); it != myList.end(); ++it) { std::cout << *it << " "; } std::cout << std::endl; // 反向迭代器遍历链表 std::list<int>::reverse_iterator rit; for (rit = myList.rbegin(); rit != myList.rend(); ++rit) { std::cout << *rit << " "; } std::cout << std::endl; return 0; } ``` 上述代码中，我们首先创建了一个包含1到5的链表`myList`。然后使用正向迭代器`std::list<int>::iterator`遍历链表并输出元素。接着使用反向迭代器`std::list<int>::reverse_iterator`从尾部开始遍历链表并输出元素。 运行上述代码，输出结果为： ``` 1 2 3 4 5 5 4 3 2 1 ``` 这就是使用STL List迭代器遍历链表的基本示例。你可以根据需要使用迭代器进行元素的访问、插入、删除等操作。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

stackY、

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值