312-STL的迭代器(1)

最新推荐文章于 2024-10-16 10:13:45 发布
最新推荐文章于 2024-10-16 10:13:45 发布
阅读量484 收藏
点赞数 1
分类专栏： 对C++STL的源码剖析 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LINZEYU666/article/details/116945679
版权

STL的迭代器(1)

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
hash_table是正向迭代器
std::slist是正向迭代器（单链表）
list是双向迭代器
dequee是双向迭代器
map和set也是双向迭代器
只有随机迭代器才可以比较大小
在这里插入图片描述
在这里插入图片描述
例子如下

在这里插入图片描述
在这里插入图片描述

迭代器的图示理解

假设有一个链表，结点有value,prev,next
我们可以通过迭代器知道它的值（数据类型），引用类型（引用的是对象的别名），指针类型（返回的是迭代器指向的结点的数据的地址，即对象实体的地址），差值类型（两个迭代器之间的距离，有几个元素），随机迭代器。
在这里插入图片描述

迭代器的讲解

R代表随机迭代器
BI代表双向迭代器
FI代表正向迭代器
栈，队列，优先级队列 没有迭代器
在这里插入图片描述

在这里插入图片描述
advance函数对不同的容器实现的方式是不一样的。
如果对所有容器的操作是统一的，对有的容器不适合，对有的容器是适合，我们要对不同的容器采取不同的方案。

在这里插入图片描述
上面代码表明 ：程序在运行的过程中才能调用这些函数。
我们希望程序在编译的过程中就可以确定调用哪个函数。
我们要获取当前迭代器的类型。
我们采取萃取方案。

STL的迭代器实现

运用了模板的重载
在这里插入图片描述
榨汁机的讲解
编译的时候就可以确定是双向迭代器
在这里插入图片描述
测试代码
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

STL的迭代器代码 iterator.h

#ifndef yhp_iterator_h
#define yhp_iterator_h
namespace yhp
{
typedef int ptrdiff_t;

//
template<class _T1, class _T2> 
struct pair 
{
	typedef _T1 first_type;
	typedef _T2 second_type;
public:
	pair(): first(_T1()), second(_T2()) {}

	pair(const _T1& _V1, const _T2& _V2): first(_V1), second(_V2) {}

	//template<class U, class V>
	//pair(const pair<U, V> &p): first(p.first), second(p.second) {}

	_T1 first;
	_T2 second;
};

template<class _T1, class _T2> inline
	bool __cdecl operator==(const pair<_T1, _T2>& _X,
		const pair<_T1, _T2>& _Y)
	{return (_X.first == _Y.first && _X.second == _Y.second); }

template<class _T1, class _T2> inline
	bool __cdecl operator!=(const pair<_T1, _T2>& _X,
		const pair<_T1, _T2>& _Y)
	{return (!(_X == _Y)); }

template<class _T1, class _T2> inline
	bool __cdecl operator<(const pair<_T1, _T2>& _X,
		const pair<_T1, _T2>& _Y)
	{return (_X.first < _Y.first ||
		!(_Y.first < _X.first) && _X.second < _Y.second); }

template<class _T1, class _T2> inline
	bool __cdecl operator>(const pair<_T1, _T2>& _X,
		const pair<_T1, _T2>& _Y)
	{return (_Y < _X); }

template<class _T1, class _T2> inline
	bool __cdecl operator<=(const pair<_T1, _T2>& _X,
		const pair<_T1, _T2>& _Y)
	{return (!(_Y < _X)); }

template<class _T1, class _T2> inline
	bool __cdecl operator>=(const pair<_T1, _T2>& _X,
		const pair<_T1, _T2>& _Y)
	{return (!(_X < _Y)); }

template<class _T1, class _T2> inline
	pair<_T1, _T2> __cdecl make_pair(const _T1& _X, const _T2& _Y)
	{return (pair<_T1, _T2>(_X, _Y)); }
///

struct input_iterator_tag {}; 
struct output_iterator_tag {};
struct forward_iterator_tag : public input_iterator_tag {};//正向迭代器 
struct bidirectional_iterator_tag: public forward_iterator_tag {};//双向迭代器 
struct random_access_iterator_tag: public bidirectional_iterator_tag  {};//随机迭代器 

template<class _C, class _Ty, class _D = ptrdiff_t,class _Pointer = _Ty*,
         class _Reference = _Ty &>
		 //迭代器类型，迭代器迭代之物，差值类型， 指针类型，随机类型 
struct iterator 
{
	typedef _C          iterator_category;
	typedef _Ty         value_type;
	typedef _D          difference_type;
	typedef _Pointer    pointer;
	typedef _Reference  reference;
};

template<class _Iterator>
struct iterator_traits//榨汁机 
{
	//iterator_traits() { }
	typedef typename _Iterator::iterator_category iterator_category;
	typedef typename _Iterator::value_type        value_type;
	typedef typename _Iterator::difference_type   difference_type;
	typedef typename _Iterator::pointer           pointer;
	typedef typename _Iterator::reference         reference;
};

template<class T>//部分特化 
struct iterator_traits<T*>  // Int 
{
	//iterator_traits() { }
	typedef random_access_iterator_tag iterator_category;
	typedef T                          value_type;
	typedef int                        difference_type;
	typedef T *                        pointer;
	typedef T &                        reference;
};

template<class T>
struct iterator_traits<const T*>
{
	//iterator_traits() { }
	typedef random_access_iterator_tag iterator_category;
	typedef T                          value_type;
	typedef int                        difference_type;
	typedef const T *                        pointer;
	typedef const T &                        reference;
};
//
// SGI
template<class _II>
inline typename iterator_traits<_II>::iterator_category
iterator_category(const _II &)
{
	typedef typename iterator_traits<_II>::iterator_category category;
	return category();
}
template<class _II>
inline typename iterator_traits<_II>::value_type *
value_type(const _II &)
{
	 return static_cast< typename iterator_traits<_II>::value_type * > (0);
}

template<class _II>
inline typename iterator_traits<_II>::difference_type *
difference_type(const _II &)
{
	 return static_cast< typename iterator_traits<_II>::difference_type * > (0);
}
///
// 
template<class _C, class _Ty, class _D> inline
_C _Iter_cat(const iterator<_C, _Ty, _D>&)
{
	_C _IterCatTag;
	_C* _pIterCatTag;
	_pIterCatTag = &_IterCatTag;	
	return (_IterCatTag); 
}
template<class _Ty> inline
random_access_iterator_tag __cdecl _Iter_cat(const _Ty *)
{
	random_access_iterator_tag _RandIterTag;
	random_access_iterator_tag* _pRandIterTag;
	_pRandIterTag = &_RandIterTag;	
	return (_RandIterTag); 
}

template<class _Ty,class _D>
struct _Bidit : public iterator<bidirectional_iterator_tag,_Ty,_D> {};//双向迭代器 
// List // Map  // Set
template<class _Ty,class _D>
struct _Ranit: public iterator<random_access_iterator_tag,_Ty,_D> {};//随机迭代器 
// dequeu // vector
template<class _Ty,class _D>
struct _Forit: public iterator<forward_iterator_tag,_Ty,_D> {};//正向迭代器 
// slist //  hashtable;

template<class _II,class _D>
inline void __advance(_II &i,_D n,input_iterator_tag )
{
	while(n--) ++i;
}

template<class _BI,class _D>
inline void __advance(_BI &i,_D n,bidirectional_iterator_tag )
{
	if(n >= 0)
	{
		while(n--) ++i;
	}
	else
	{
		while(n++) --i;
	}
}

template<class _RI,class _D>
inline void __advance(_RI &i,_D n,random_access_iterator_tag )
{
	i += n;
}
template<class _II,class _D>
inline void advance(_II &i,_D n)
{
	//iterator_traits<_II>();
	//typedef typename iterator_traits<_II>::iterator_category  cate;
	//__advance(i,n,cate());
	__advance(i,n,iterator_category(i));
}

template<class _II>
inline typename iterator_traits<_II>::difference_type 
__distance(_II _F , _II _L, input_iterator_tag)
{
	typename iterator_traits<_II>::difference_type  n = 0;
	while(_F != _L)
	{
		++_F;
		++n;
	}
	return n;
}

template<class _II>
inline typename iterator_traits<_II>::difference_type 
__distance(_II _F , _II _L, random_access_iterator_tag)
{
	return _L - _F;
}
template<class _II>
inline typename iterator_traits<_II>::difference_type 
distance(_II _F , _II _L)
{
	typedef typename iterator_traits<_II>::iterator_category  cate;
	return __distance(_F,_L,cate());
}

}

#endif
林林林ZEYU
关注
专栏目录
c++实现迭代器模式完整源代码
希望我的博客，能帮上你解决学习中工作中所遇到的问题
05-28 382
c++实现迭代器模式完整源代码Iterator.hAggregate.hAggregate.cppmain.cpp Iterator.h #ifndef _ITERATOR_H_ #define _ITERATOR_H_ #pragma once #include "Aggregate.h" #include <vector> using namespace std; // 抽象迭代器 class Iterator { public: Iterator(){} virtual ~Ite
(入门自用)C++--STL-string-迭代器
qq_68741368的博客
08-25 790
标准模板库，是C++标准库的重要组成部分。
c++迭代器简单代码
黑檀木
07-15 670
c++提供了下边及迭代器两种方式来访问容器里的元素，对于迭代器个人感觉就像是一个用于容器的特殊指针，用书上的话来说就是一种检查容器内元素并遍历元素的数据类型（类），它自身也支持自增自减操作，可以和指针比较着学习； 下面代码求vector容器中各个元素中x，y相乘值的总和 其中fflush(stdin);用于清空输入缓存 #include #include using namespac
C++进阶——STL源码之迭代器（iterators）
qq_25065595的博客
08-01 1555
STL迭代器 在 STL 编程中，容器和算法是独立设计的，即数据结构和算法是独立设计的，连接容器和算法的桥梁就是迭代器了： 迭代器是一种行为类似指针的对象，而指针的各种行为中最常见也最重要的使用是：内容提领 和成员访问，所以迭代器会对operator* 和 operator-> 进行重载工作，首先来看下list容器的迭代器实现： template<typename _Tp> struct _List_iterator { typedef _List
C/C++编程：STL 迭代器源码与 traits 编程学习
OceanStar的博客
01-23 436
在STL编程中，算法和容器时独立设计的，容器里面存放的是数据，而算法则是提供了对数据的操作，在算法操作数据的过程中，要用到迭代器，迭代器可以看作是算法和容器之间的桥梁
迭代器源码
12-20
[C#基础知识系列]专题十二:迭代器源码
浅谈c++ stl迭代器失效的问题
08-31
本文将深入探讨STL迭代器失效的问题，特别是在执行插入（insert）和删除（erase）操作时。 首先，让我们来看一下在删除元素时迭代器失效的情况。迭代器失效是指在执行某些操作后，原本有效的迭代器变得不可用，通常...
SGI-STL:SGI-STL原始资源下载+个人注释
03-06
这个资源包“SGI-STL:SGI-STL原始资源下载+个人注释”包含了SGI-STL的原始代码以及个人的注解，对于深入理解C++中的STL和容器、算法、迭代器等概念非常有帮助。 首先，让我们来了解一下SGI-STL的核心组成部分： 1....
C++课程小作业-STL容器与迭代器的实现路径-设计类vector容器myVector
06-14
STL是高效的C++程序库，是大量类模板和函数模板的聚集，主要的组成部分包括容器、迭代器、算法、函数等。其中容器是存放对象的集合，使用类模板方式; 选代器是容器与算法的粘合剂，是所谓的泛型指针, 使用类模板方式...
SGI-STL 迭代器实现
蔡曜镫专栏
03-02 833
SGI-STL 迭代器实现 迭代器模式：该模式能够提供一种方法，使之能够依序寻访某个聚合物（容器）所含的每个元素，而又无需暴露该聚合物的内部表达方式。 ———————————————————————————————————————— 《STL源码剖析》 它是什么？它其实就是算法与容器的一种粘胶剂。它像什么？迭代器的行为非常类似智能指针（SmartPointer），所以对他来说最重
迭代器模式（Iterator）C++实现
03-14
迭代器模式（Iterator）C++实现
迭代器比较 const_iterator
chenzhen1213的专栏
11-12 1336
用==或！=操作符来比较两个迭代器，如果两个迭代器
C++迭代器模拟代码（学习记录）
Duxingcan的博客
10-23 128
学习使用，没大规模测试，通用改模板 #include <memory.h>#include <stdexcept> #include <assert.h> class CArrary { public: //迭代器类，保护成员 class iterator { public: iterator& operator++() { .
黑白迭代c++源代码
kxleo的博客
07-09 811
黑白迭代功能模块随机取数隐藏光标定位函数（光标移动函数）输出函数输出‘要求’输出目前的棋盘状态输出题目输出边界输出行列的位置输出全部棋盘输出结束语输出菜单输出答案输出欢迎界面输出结束语输出规则界面隐藏问题重置棋盘检查答案撤销主函数头文件定义问题数组答案数组小小的问题注意 功能模块 随机取数 一定要注意这里必须要初始化随机数种子，否则你每一次运行随机取的数会相同。 /***随机数***/ int rand_srand(int x){ srand((unsigned)time(NULL)); return
STL之迭代器
qq_19525389的博客
08-05 362
3.1迭代器设计思维—STL 关键所在  STL 的中心思想在于，将数据容器（ containers）和算法（ algorithms）分开，彼此独立设计，最后再以一帖胶着剂将它们撮合在一起。容器和算法的泛型化，从技术角度来看并不困难， C++ 的 class templates 和 function templates可分别达成目标。如何设计出两者之间的良好胶着剂，才是大难题。  3.2迭代器...
C++——STL库中迭代器以及其代码实现简介
TaloyerG的博客
02-15 255
文章目录一、STL库中迭代器的简介1.迭代器的定义2.迭代器常用的运算3.vector和deque提供的额外运算4.迭代器的取值范围二、STL库中迭代器的代码实现总结 一、STL库中迭代器的简介 1.迭代器的定义 迭代器(iterator)是一种对象，它能够用来遍历标准模板库容器中的部分或全部元素，每个迭代器对象代表容器中的确定的地址。像使用指针遍历数组一样，可以使用迭代器来遍历容器。 2.迭代器常用的运算 *ite 返回迭代器所指向的元素的引用。 ite->men 获取指定元素中
C++ STL源码学习(迭代器篇)
alpaca.blog
09-21 1172
QQ:2496088963  欢迎联系交流
Javascript和C# Linq迭代器比较
weixin_43263355的博客
01-24 940
概要 无论前端后端，迭代器在我们的开发中大量使用。本文主要从实现和原理两个方面，比较JS和C#中迭代器，从而加深我们对迭代器这种编程模式的理解。 代码实现 本文通过迭代一个学生属性的实例来实现JS和C#迭代器。 JS迭代器的实现 var student = { 0: "XC-001", 1: "Tom", 2: "Room-01", length : 3 } student.__proto__[Symbol.iterator] = function(){ var cu
【C++刷题】力扣-#121-买卖股票的最佳时机
最新发布
会写代码的饭桶
10-16 216
给定一个数组 prices，其中 prices[i] 表示第 i 天的股票价格。假设你可以在第 i 天买入并在第 j 天卖出股票（i ≤ j），设计一个算法来计算你所能获取的最大利润。注意你只能持有一股股票，并且你不能同时参与多笔交易（即在再次买入前必须卖出股票）。
STL迭代器详解：从输入到随机访问
"STL迭代器是C++标准模板库中的一个重要组成部分，它提供了一种方式来遍历容器中的元素。迭代器根据其功能和能力分为五种主要类型：输入迭代器、输出迭代器、前向迭代器、双向迭代器和随机访问迭代器。这些迭代器...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

林林林ZEYU

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

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

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

打赏作者

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

抵扣说明：

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

余额充值