C++——实现一个简单的迭代器

已于 2022-10-16 21:47:25 修改
阅读量3.6k 收藏 25
点赞数 5
文章标签： c++ 链表 开发语言
于 2022-10-14 16:51:45 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_67452474/article/details/127322118
版权

迭代器

1、迭代器的原理

为了提高C++编程的效率，STL中提供了许多容器，包括vector、list、map等。为了统一访问方式，STL为每种容器在实现的时候设计了一个内嵌的iterator类，不同的容器有自己专属的迭代器，使用迭代器来访问容器中的数据。迭代器对一些基本操作如*、–、++、==、!=进行了重载，使其具有了遍历复杂数据结构的能力，其遍历机制取决于所遍历的容器，迭代器的使用和指针的使用非常相似。通过begin，end函数获取容器的头部和尾部迭代器，当begin和end返回的迭代器相同时表示容器为空。简单来说，迭代器就是一个遍历的过程，像使用指针一样使用迭代器就可以访问这个容器。

  • 迭代器就是一个类的对象，通过对这个类对象进行操作（如：++, --等）可以实现对容器的遍历，这样用户便可以不用关心它的实现。

在这里插入图片描述

  • 如上图所示：迭代器有三成员，但都是指针，并且一个容器里面会存在两个迭代器，一个是起始迭代器(begin)，一个是终止迭代器(end)。
  • 起始迭代器：起始指针始终指向起始位置，终止指针始终指向容器最后一个位置,现在指针（可能叫法不太严谨）可以指向容器中的任意位置，但可以通过重载运算符(++,–)来操作现在指针指向的位置。
  • 终止迭代器：起始指针和终止指针是一样的，现在指针不一样，现在指针始终是指向终止指针的后面一个（也就是null），一直指向null。

2、迭代器的实现

定义一个迭代类所需要的操作：
在这里插入图片描述
这里我们使用一下之前我写过的一个链表容器来辅助实现：

class iterator//迭代类
	{
	private:
		node* m_start;//起始指向
		node* m_cur;//现在指向
		node* m_end;//中止指向
	public:
		iterator(node* start, node* cur, node* end): m_start(start), m_cur(cur), m_end(end){}
		T& operator*() {//重载*运算符
			if (m_cur == nullptr)
				throw underflow_error("链表为空。");//抛出异常
			else
				return m_cur->m_data;
		}
		//重载++运算符
		iterator& operator++() {
			if (m_cur == nullptr)
				m_cur = m_start;
			else
				m_cur = m_cur->m_next;
			return *this;
		}
		//重载--运算符
		iterator& operator--() {
			if (m_cur == nullptr)
				m_cur = m_tail;
			else
				m_cur = m_cur->pre;
			return *this;
		}

		//重载==运算符
		bool operator==(const iterator& that)const {
			return m_start == that.m_start && m_cur == that.m_cur && m_end == that.m_end;
		}
		//重载!=运算符
		bool operator!=(const iterator & that)const {
			return !(*this == that);
		}
		friend class list;
	};

这个迭代类是定义在链表容器类里面的成员类，下面总代码中就知道了。

  • 我们做了迭代类的实现，但我们还要实现一下迭代器的对象，我们需要在链表类里面定义一个函数用来实现迭代类的对象，也就是迭代器，我们分别定义begin和end两个迭代器。
//创建迭代器
	iterator begin() {
		return iterator(m_head, m_head, m_tail);
	}

	//创建第二个迭代器
	iterator end() {
		return iterator(m_head, nullptr, m_tail);
	}

这样我们只要创建一个容器的对象来调用这两个函数就产生两个迭代器了，然后用迭代类里面的重载运算符就可以使用迭代器遍历容器了。

3、容器查找

查找很简单，遍历判断就行了：

template<class IT, class TD>
IT find(const IT &begin, const IT &end, const TD& number)
{
	for (IT it = begin; it != end; ++it)
	{
		if (*it == number)
			return it;
	}
	return end;
}

4、容器排序

我们要为一个容器写一个排序函数对容器进行排序。
我们采用快速排序的方式，那我们先来讲一下什么是快速排序：
在这里插入图片描述

排序（"<"）
template<class IT>
void sort(const IT& begin, const IT& end)
{
	IT p = begin;
	IT last = end;
	--last;
	
	for (IT i = begin, j = last; i != j;)
	{
		while (i != p && *i < *p)//两个变量不相等并且i<p的值就++
			++i;
		if (i != p)
		{
			swap(*i, *p);
			p = i;
		}
		while (j != p && *p < *j)
			--j;
		if (j != p)
		{
			swap(*p, *j);
			p = j;
		}
		
	}
	IT be = begin;
	++be;
	if (p != begin && p != be)
		sort(begin, p);//递归左边
	be = p;
	++be;
	if (be != end &&  be!= last)
		sort(be, end);//递归右边
}

代码可能有点烂，但能力之内了，请见谅。
但我们这样的话就只能升序了，而如果想要降序的话就还需要重新写一个函数，这样的话就非常麻烦，所以我们可以实现一个比较器来配合着上面这个代码，就相当于进行了一个优化。

比较器：简单来说就是一个类，制造容器的人不负责制造比较器这个类，需要用户自己来定义一个这样的类。

//一个简单的比较器
lass MSD
{
public:
	bool operator()(int a, int b) {
		return a > b;//可以是大于或小于
	}
};

//排序(比较器)
template<class IT, class MSD>//MSD是一个类
void sort(const IT& begin, const IT& end, MSD msd)
{
	IT p = begin;
	IT last = end;
	--last;

	for (IT i = begin, j = last; i != j;)
	{
		while (i != p && msd(*i, *j))
			++i;
		if (i != p)
		{
			swap(*i, *p);
			p = i;
		}
		while (j != p && msd(*p, *j))
			--j;
		if (j != p)
		{
			swap(*p, *j);
			p = j;
		}

	}
	IT be = begin;
	++be;
	if (p != begin && p != be)
		sort(begin, p, msd);
	be = p;
	++be;
	if (be != end && be != last)
		sort(be, end, msd);
}

总代码

#include<iostream>
using namespace std;

template<typename T>
class list
{
private:
	class node//节点
	{
	public:
		node(const T &data, node * p, node* n): m_data(data),m_pre(p), m_next(n){}
		T m_data;
		node* m_pre;//前驱
		node* m_next;//后继
	};
	node* m_head;//链表头节点
	node* m_tail;//链表未节点
public:
	class iterator
	{
	private:
		node* m_start;//起始指向
		node* m_cur;//现在指向
		node* m_end;//中止指向
	public:
		iterator(node* start, node* cur, node* end): m_start(start), m_cur(cur), m_end(end){}
		T& operator*() {//重载*运算符
			if (m_cur == nullptr)
				throw underflow_error("链表为空。");//抛出异常
			else
				return m_cur->m_data;
		}
		//重载++运算符
		iterator& operator++() {
			if (m_cur == nullptr)
				m_cur = m_start;
			else
				m_cur = m_cur->m_next;
			return *this;
		}
		//重载--运算符
		iterator& operator--() {
			if (m_cur == nullptr)
				m_cur = m_end;
			else
				m_cur = m_cur->pre;
			return *this;
		}

		//重载==运算符
		bool operator==(const iterator& that)const {
			return m_start == that.m_start && m_cur == that.m_cur && m_end == that.m_end;
		}
		//重载!=运算符
		bool operator!=(const iterator & that)const {
			return !(*this == that);
		}
		friend class list;
	};
	//创建迭代器
	iterator begin() {
		return iterator(m_head, m_head, m_tail);
	}

	//创建第二个迭代器
	iterator end() {
		return iterator(m_head, nullptr, m_tail);
	}

	//利用迭代器添加元素
	void add(iterator& that, const T &num)
	{
		if (that == end())
			push_back(num);
		else
		{
			node* p = new  node(num, that.m_cur->m_pre, that.m_cur);
		
			if (that.m_cur->m_pre)
				that.m_cur->m_pre->m_next = p;
			else
				m_head = p;
			p->m_next->m_pre = p;
		}
	}

	//删除元素
	void eares(iterator& that)
	{
		if (that == end())
			return;
		node* p = that.m_cur;
		if (p->m_pre)
			p->m_pre->m_next = p->m_next;
		else
			m_head = p->m_next;
		if (p->m_next)
			p->m_next->m_pre = p->m_pre;
		else
			m_tail = p->m_pre;
		delete p;
	}

	//缺省构造
	list():m_head(nullptr), m_tail(nullptr){}

	//复制构造
	list(const list& that) {
		for (node* p = that.m_head; p; p = p->m_next)
			push_back(p->m_data);
	}

	//析构函数
	~list() {
		clear();
	}
	
	//判断链表是否为空
	bool empty() {
		return m_head == nullptr && m_tail == nullptr;
	}

	//链表清空
	void clear() {
		while (!empty())
			pop_prent();
	}

	//添加头节点
	void push_prent(const T & data) {
		m_head = new node(data, nullptr, m_head);
		if (m_head->m_next)
			m_head->m_next->m_pre = m_head;
		else
			m_tail = m_head;
	}

	//删除头节点
	void pop_prent() {
		if (empty())
			return;
		node* ponde = m_head->m_next;
		delete m_head;
		if (ponde)
			ponde->m_pre = nullptr;
		else
			m_tail = nullptr;
		m_head = ponde;
	}

	//添加未节点
	void push_back(const T& data) {
		m_tail = new node(data, m_tail, nullptr);
		if (m_tail->m_pre)
			m_tail->m_pre->m_next = m_tail;
		else
			m_tail = m_head;
	}

	//删除尾节点
	void pop_back() {
		if (empty())
			return;
		node* ponde = m_tail->m_pre;
		delete m_tail;
		if (ponde)
			ponde->m_next = nullptr;
		else
			m_head = nullptr;
		m_tail = ponde;
	}

	//获取链表头元素
	T& get_prent() {
		if (empty())
			throw underflow_error("链表为空。");//抛出异常
		return m_head->m_data;
	}
	const T& get_prent() const {
		return const_cast<list*>(this)->get_prent();
	}

	//获取链表未元素
	T& get_back() {
		if(empty())
			throw underflow_error("链表为空。");//抛出异常
		return m_tail->m_data;
	}
	const T& get_back()const {
		return const_cast<list*>(this)->get_back();
	}

	//获取链表大小
	size_t get_size() {
		size_t i = 0;
		for (node* p = m_head; p; p = p->m_next)
			++i;
		return i;
	}
};

//利用迭代器遍历打印
void print(list<int> & ls)
{
	using IT = list<int>::iterator;
	for (IT it = ls.begin(); it != ls.end(); ++it)
	{
		cout << *it << "   ";
	}
	cout << endl;
}

//查找
template<class IT, class TD>
IT find(const IT &begin, const IT &end, const TD& number)
{
	for (IT it = begin; it != end; ++it)
	{
		if (*it == number)
			return it;
	}
	return end;
}

//一个简单的比较器
lass MSD
{
public:
	bool operator()(int a, int b) {
		return a > b;//可以是大于或小于
	}
};

//排序(比较器)
template<class IT, class MSD>//MSD是一个类
void sort(const IT& begin, const IT& end, MSD msd)
{
	IT p = begin;
	IT last = end;
	--last;

	for (IT i = begin, j = last; i != j;)
	{
		while (i != p && msd(*i, *j))
			++i;
		if (i != p)
		{
			swap(*i, *p);
			p = i;
		}
		while (j != p && msd(*p, *j))
			--j;
		if (j != p)
		{
			swap(*p, *j);
			p = j;
		}

	}
	IT be = begin;
	++be;
	if (p != begin && p != be)
		sort(begin, p, msd);
	be = p;
	++be;
	if (be != end && be != last)
		sort(be, end, msd);
}

//代码实现
//-----------------------------
//代码使用

int main()
{
	list<int> ls;
	for (int i = 0; i < 5; i++)
		ls.push_prent(10 + i);
	for (int i = 0; i < 5; i++)
		ls.push_back(100 + i);
	print(ls);

	using IT = list<int>::iterator;
	IT it = ls.begin();
	
	ls.eares(it);//删除it所指向的节点
	print(ls);
	cout << "--------------------" << endl;
	IT ib = ls.begin();
	ls.add(++ib, 120);//添加节点到第二位置
	print(ls);
	
	cout << "---------" << endl;
	cout << "找到一个数并删除它：" << endl;
	IT its = finds(ls.begin(), ls.end(), 100);
	if (its != ls.end())
		ls.eares(its);
	print(ls);

	cout << "-----排序-----" << endl;
	MSD  msd;
	sort(ls.begin(), ls.end(), msd);
	print(ls);
	return 0;
}

可能说的有点不好，但需要你学习关于链表的知识才能搞清楚这个知识。

小白学编程*
关注
  • 5
    点赞
  • 踩
  • 25
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
C++实现一个简单的Circle
Jing Sir的博客
04-25 9878
如下所示，这是一个简单的圆圈： class Point//点类 { private: double x,y; public: Point(double x=0.0,double y=0.0);//点的坐标初始化 void disp();//输出 double distance(Point p1,Point p2);//计算两点间距离 }; Point::Point(double x,double y) { this->x=x; this->y
C++ 简单实现压栈出栈
weeks
04-06 3591
/********************************************************************** * Copyright (c)2015,WK Studios * Filename: stack.h * Compiler: GCC,VS,VC6.0 win32 * Author:WK * Time: 2015 3 29
C++迭代器（STL迭代器）iterator详解
又帅又酷的红头发10号
04-14 1万+
转自http://c.biancheng.net/view/338.html。侵删。 要访问顺序容器和关联容器中的元素，需要通过“迭代器（iterator）”进行。迭代器是一个变量，相当于容器和操纵容器的算法之间的中介。迭代器可以指向容器中的某个元素，通过迭代器就可以读写它指向的元素。从这一点上看，迭代器和指针类似。 迭代器按照定义方式分成以下四种。 1) 正向迭代器，定义方法如下： 容器类名...
[C++] 迭代器
A_ns_wer_的博客
08-03 6837
对迭代器的介绍
迭代器解释(C++)
最新发布
m0_61990249的博客
05-06 1157
迭代器解释(C++)
【C++】迭代器
Qiuhan_909的博客
04-03 5267
1. 迭代器 2. begin和end成员 3. 容器操作可能使迭代器失效 4. 反向迭代器
C++迭代器
weixin_41368411的博客
04-18 1万+
什么是迭代器： C++中，迭代器就是一个类似于指针的对象，它能够用来遍历C++标准模板库容器中的部分或全部元素，每个迭代器对象代表容器中的确定的地址。以下面的string为例子介绍说明。 对string 对象s1正向遍历输出，代码如下所示： string::iterator it = s.begin(); //此处的begin()函数有两个重载函数，分别是 //iterator begin(); //const_iterator begin() const; //调用他们的对象，分别是可以
C++ 迭代器
2201_75772333的博客
05-16 1051
STL提供了一系列通用的迭代器类型，包括输入迭代器（Input Iterator）、输出迭代器（Output Iterator）、前向迭代器（Forward Iterator）、双向迭代器（Bidirectional Iterator）和随机访问迭代器（Random Access Iterator）。不同的迭代器类型具有不同的功能和操作能力，可以适应不同类型的容器和算法的需求。迭代器可以被看作是一种指针，用于指向容器中的特定位置或元素，通过迭代器可以访问和操作容器中的数据。返回向量的起始位置的迭代器，
C++STL之迭代器（iterator）详解
weixin_74334323的博客
04-16 3347
答：迭代器是一种检查容器内元素并且遍历容器内元素的数据类型。😧（看不懂，没关系，c语言学过吧，指针知道吧，没错，这就和访问数组的指针类似，指针是C语言里面就有的东西，而迭代器是C++里面才有的，二者还有其他区别，之后再整理😁）
详解Java设计模式——迭代器模式
08-26
在实现迭代器模式时，需要定义两个实现类：MyCollection和MyIterator。MyCollection类实现了Collection接口，定义了集合的一些操作，而MyIterator类实现了Iterator接口，定义了一系列迭代操作。 使用迭代器模式可以...
什么是C++的迭代器.docx
10-23
在C++中，迭代器就像一个指针，可以指向容器内的元素，但它比指针功能更强大，因为迭代器提供了更多的操作，如前移、后移以及访问元素等。迭代器不仅支持基本的递增运算（++），还可能包含其他特定于容器的高效操作...
C++程序设计教程——设计思想与实现习题代码答案
12-07
《C++程序设计教程——设计...总之，《C++程序设计教程——设计思想与实现习题代码答案》是一份宝贵的教育资源，它将理论知识与实际操作相结合，全面覆盖了C++的关键概念和技术，为学习者提供了一个扎实的C++编程基础。
C++——STL
04-06
C++ STL，全称为Standard Template Library（标准模板库），是C++编程语言中不可或缺的一部分，它为程序员提供了高效且灵活的容器、迭代器、算法和函数对象等工具，极大地提升了代码的可读性和复用性。STL的核心概念...
C/C++实现感知器算法
01-10
以下是一个简单的C++实现感知器算法的伪代码框架： ```cpp struct Sample { std::vector<double> features; int label; }; class Perceptron { public: Perceptron(double learning_rate, int max_epochs); ...
C++ 迭代器iterator
2201_75772333的博客
05-11 1783
在 C++ 中，迭代器（iterator）是一种通用的抽象概念，用于在容器（如std::liststd::map等）中遍历和访问元素。迭代器提供了一种统一的接口，使得不同类型的容器可以以相似的方式进行遍历和操作。大多数 C++ 容器都提供了迭代器，用于遍历容器中的元素。例如，和std::deque提供了随机访问迭代器，std::list提供了双向迭代器，std::set和std::map提供了双向迭代器。
c++迭代器
TOPEE362的博客
08-07 2800
迭代器有关函数, boost库的迭代器工具
C++ 迭代器(iterator)超详解+实例演练
热门推荐
qq_52324409的博客
11-13 4万+
C++ STL 迭代器详解一级目录二级目录三级目录 一级目录 二级目录 三级目录
C++ 迭代器 iterator 详解
WWester的博客
09-02 1489
迭代器 功能：访问容器对象的元素。所有标准库容器都可以使用迭代器，其中只有少数几种才同时支持下标运算符。严格来说，string对象不属于容器类型，但是string支持很多与容器类型类似的操作。迭代器分为有效和无效，类似于指针。有效的迭代器：指向某个元素，或者指向容器中尾元素的下一个位置；无效的迭代器：除上述的其他所有情况。
C++ 迭代
06-01
C++ 迭代指的是通过循环遍历数据结构中的每个元素。C++ 中常用的迭代方式有 for 循环、while 循环和 do-while 循环。其中，for 循环最常用，可以通过定义一个迭代变量来控制循环次数，如下所示： ```c++ for (int i = 0; i < n; i++) { // 迭代操作 } ``` 其中，n 表示需要迭代的次数，i 表示迭代变量，可以在循环中使用。 除了 for 循环，C++ 中还支持使用迭代器来遍历容器中的元素，例如 vector、list 等。使用迭代器可以更加灵活地遍历容器中的元素，如下所示： ```c++ vector<int> nums = {1, 2, 3, 4, 5}; for (auto it = nums.begin(); it != nums.end(); ++it) { // 迭代操作，*it 表示当前迭代到的元素 } ``` 其中，nums.begin() 返回容器中第一个元素的迭代器，nums.end() 返回容器中最后一个元素的下一个位置的迭代器。在循环中，可以使用 *it 访问当前迭代到的元素。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

小白学编程*

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

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

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

打赏作者

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

抵扣说明：

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

余额充值