STL源码剖析 5中迭代器型别
2024-06-01 02:41:23
- 最常使用的5种迭代器的型别 为 value_type、difference_type、pointer、reference、iterator_category。
- 如果想要自己开发的容器和STL进行适配，就需要定义上述5种类型
- iteraor_traits 必须针对传入的型别为 pointer 或者 pointer-to-const设计偏特化版本
template <class I>
struct iteraor_traits{typedef typename I::iterator_category iterator_category;typedef typename I::value_type value_type;typedef typename I::difference_type difference_type;typedef typename I::pointer pointer;typedef typename I::reference reference;
};value_type
- 迭代器所指对象的型别
difference_type
- 两个迭代器之间的距离，表示容器的最大容量([begin,end))
- 例：STL 的count() 返回的数值就是迭代器的 difference type
template <class I>
struct iteraor_traits{typedef typename I::iterator_category iterator_category;typedef typename I::value_type value_type;typedef typename I::difference_type difference_type;typedef typename I::pointer pointer;typedef typename I::reference reference;
};template <class I,class T>
typename iteraor_traits<I>::difference_type //这一整行限定的是函数的回返型别
count (I first,I last,const T& value){typename iteraor_traits<I>::difference_type n = 0;for (;first != last;++first) {if (*first == value){++n;}}return n;
}- 针对相应型别differe type,traits 的如下两个(针对原生指针而写的)特化版本
- 使用C++内建的ptrdiff_t （定义在<cstddef>头文件） 作为原生指针的difference type
//针对原生指针设计的偏特化版本
template <class T>
struct iteraor_traits<T*>{typedef ptrdiff_t difference_type;
};//针对原生的pointer-to-const设计的偏特化版本
template <class T>
struct iteraor_traits<const T*>{typedef ptrdiff_t difference_type;
};- 当我们需要的任何迭代器I的difference type，可以怎么写 typename iterator_traits<I>::difference_type
pointer
- 指针和引用之间的关系是非常密切的，传回一个左值，令他代表所指之物，也可以令其代表所指之物的地址，即可以通过传回一个指针，指向迭代器的所指之物
Item& operator*() const {return *ptr;}
Item* operator->() const {return ptr;}//针对原生指针设计的偏特化版本
template <class T>
struct iteraor_traits<T*>{typedef T* pointer;typedef T& reference;
};//针对原生的pointer-to-const设计的偏特化版本
template <class T>
struct iteraor_traits<const T*>{typedef const T* pointer;typedef const T& reference;
};reference
- 从迭代器所指之物的内容是否允许改变的角度出发，迭代器分为两种：不允许改变所指对象的内容 称为const int*pic
- 允许改变所指之物的内容 称为mutable iterators ，例如int * pi；
- 对于mutable iterator进行提领操作的时候，得到的不是一个右值(右值不允许赋值操作)，应该是一个左值。
int *pi = new int(5);const int* pci = new int(9);*pi = 7; //对mutable iterator进行提领操作的时候 得到的是左值，允许赋值*pci = 1; //这个操作是不允许的，pci是const iterator//提领pci得到的结果是一个 右值 不允许赋值- C++左值是通过reference的方式返回的
- 当p是mutable iterator时，其value type是T 那么*p型别不应该是T 应该是T&
- 当p是constant iterator时，其value type是const T 那么*p型别不应该是const T 应该是const T&
iterator_category
//针对原生指针设计 偏特化版本
template <class T>
struct iteraor_traits<T*>{//注意 原生指针是一种Random access iteratortypedef random_access_iterator_tag iterator_category;
};//针对原生指针 pointer-to-const 设计 偏特化版本
template <class T>
struct iteraor_traits<const T*>{//注意 原生指针pointer-to-const 是一种Random access iteratortypedef random_access_iterator_tag iterator_category;
};迭代器的分类( 根据移动特性和施行操作 )
- Input iterator :不允许外界改变 只读
- output iterator：唯写
- forward iterator：允许写入型算法 (例如 replace() ) 在这种迭代器形成的区间上进行读写操作
- bidirectional iterator : 可以双向移动 ，可以逆向访问迭代器的区间(例如逆向 拷贝某个范围内的元素)
- random access iterator : 前四种仅仅具备一部分指针算数的能力(前三种支持operator++，第四种需要加上operator--)；第五种需要涵盖所有的只针的算数的能力，比如p+n p-n p[n] p1-p2 p1<p2
- 直线和箭头并不代表 继承的关系，而是所谓的 概念 和强化的关系
- 例子 使用advance函数举例，这个函数有两个参数，迭代器p和数值n，函数需要实现迭代器p累计前进n次
- 3个例子：input iterator、bidirectional iterator 、random access iterator
- 倒是没有针对forwarditerator设计的版本，因为这个 和 inputiterator而设计的版本完全一致
template <class InputIterator,class Distance>
void advance_II(InputIterator& i,Distance n){//单向 逐一前进while (n--)++i;
}template <class BidirectionalIterator,class Distance>
void advance_BI(BidirectionalIterator& i,Distance n){//双向 逐一前进if(n >= 0){while (n--){++i;}} else{while (n++){--i;}}
}template <class RandomAccessIterator,class Distance>
void advance_RAI(RandomAccessIterator&i ,Distance n){//双向 跳跃前进i += n;
}- 程序调用advance()的时候 具体使用哪一个函数定义呢？如果选择advance_II（）对于randomaccess iterator而言 缺乏效率，O(1)操作变成了O(N)操作
- 如果是advance_RAI（） 则无法接受 Input Iterator 需要对上述三个函数进行合并
template <class InputIterator,class Distance>
void advance(InputIterator& i,Distance n){if (is_random_access_iterator(i)){advance_RAI(i,n);} else if (is_bidiractional_iterator(i)){advance_BI(i,n);} else{advance_II(i,n);}
}- 在执行期间决定使用哪一个版本，会影响程序的执行的效率，最好在编译期间就确定程序执行的正确的版本，因此使用函数的重载是最好的方式
struct _LIBCPP_TEMPLATE_VIS input_iterator_tag {};
struct _LIBCPP_TEMPLATE_VIS output_iterator_tag {};
struct _LIBCPP_TEMPLATE_VIS forward_iterator_tag : public input_iterator_tag {};
struct _LIBCPP_TEMPLATE_VIS bidirectional_iterator_tag : public forward_iterator_tag {};
struct _LIBCPP_TEMPLATE_VIS random_access_iterator_tag : public bidirectional_iterator_tag {};- 上述这些classes只能作为标记使用，不需要任何成员
- 加上第三个参数，让他们之间形成重载的关系
template <class InputIterator,class Distance>
void __advance(InputIterator& i,Distance n,input_iterator_tag){//单向 逐一前进while (n--)++i;
}//这是一个单纯的传递调用的函数(trivial forwarding function)
template <class ForwardIterator,class Distance>
inline void __advance(ForwardIterator&i, Distance n,forward_iterator_tag){//单纯的进行传递调用 (forwarding)advance(i,n,input_iterator_tag());
}template <class BidirectionalIterator,class Distance>
void advance_BI(BidirectionalIterator& i,Distance n,bidirectional_iterator_tag){//双向 逐一前进if(n >= 0){while (n--){++i;}} else{while (n++){--i;}}
}template <class RandomAccessIterator,class Distance>
void advance_RAI(RandomAccessIterator&i ,Distance n,random_access_iterator_tag){//双向 跳跃前进i += n;
}- __advance()的第三个参数只声明了型别，但是并没有指定参数的名称，其主要的目的是为了激活重载机制，函数中根本不使用这个参数
- 还需要一个对外开放的上层控制接口，调用上述的各自重载的__advance() ，这一层只需要两个参数，当其准备将工作转移给上述的_advance()时才会自行加上第三个参数：迭代器的类型。
- 使用traits机制 从所获得的迭代器中推导出 其类型
template <class I>
struct iteraor_traits{typedef typename I::iterator_category iterator_category;typedef typename I::value_type value_type;typedef typename I::difference_type difference_type;typedef typename I::pointer pointer;typedef typename I::reference reference;
};template <class InputIterator,class Distance>
inline void advance(InputIterator&i, Distance n){__advance(i,n,iteraor_traits<InputIterator>::iterator_category());
}- iteraor_traits<InputIterator>::iterator_category() 将产生一个暂时对象，就像int() 产生一个int暂时对象一样。
- 这个临时对象的型别应该隶属于前面所述的5个迭代器之一，然后根据这个 迭代器的型别，编译器才决定调用哪一个_advance()重载函数
注意事项
- 迭代器其类型隶属于各个适配类型中最强化的那个。例如int* 既是random 、bidirectional、forward、input，那么其类型应该从属为random_access_iterator_tag
- 但是迭代器的参数需要按照最低阶的类型为其命名，比如advance（）函数，使用最低级的inputIterator为其命名
消除 “单纯传递调用的函数”
- 使用class定义迭代器的各种分类标签，不仅可以促进重载机制的成功运作，使得编译器得以正确执行重载决议，overloaded resolution
- 还可以 通过继承不比再写 "单纯只做传递调用"的函数，即advance不需要写 Forwarditerator这个版本
- 仿真测试tag types继承关系所带来的影响
- 例子：使用distance举例子 计算两个迭代器之间的距离
- distance可以接受任何类型的迭代器，但是template型别参数设置为InputIterator，是为了遵循STL算法的命名规则，使用最低级的迭代器命名
- 考虑到继承关系，当客户端调用distance()函数输入的参数型别是 Output iterators、Bidirectional Iterators、ForwardIterator时，统统都会转化为Input Iterator版_distance函数
- 即存在继承关系的模型，仅仅实现首 和 尾即可，中间版本都会被隐式转化为首，尾巴调用专属的函数即可
std::iterator 保证
- 规范需要任何的迭代器都需要实现上述的五个内嵌的型别，从而方便traits进行类型的萃取，否则无法适配 STL的组件
- STL提供了iterator class，新设计的迭代器需要继承自它，它不包含任何的成员，只是进行了型别的定义，因此继承它 不会导致额外的负担
#include <memory>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{};//自行开发的迭代器需要继承 std::iterator
template <class Category,class T,class Distance = ptrdiff_t,class Pointer = T*,class Reference = T&>
struct iterator{typedef Category iterator_category;typedef T value_type;typedef Distance difference_type;typedef Pointer pointer;typedef Reference reference;
};//traits
template <class Iterator>
struct 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;
};//针对原生指针(native pointer)设计traits偏特化版本
template <class T>
struct iterator_traits<T*>{typedef random_access_iterator_tag iterator_category;typedef T value_type;typedef ptrdiff_t difference_type;typedef T* pointer;typedef T& reference;
};//针对原生指针(pointer-to-const)设计的traits偏特化版本
template <class T>
struct iterator_traits<const T*>{typedef random_access_iterator_tag iterator_category;typedef T value_type;typedef ptrdiff_t difference_type;typedef T* pointer;typedef T& reference;
};//函数的目的是为了 方便的决定某个迭代器的类型 (category)
template <class Iterator>
inline typename iterator_traits<Iterator>::iterator_category
iterator_category(const Iterator&){typedef typename iterator_traits<Iterator>::iterator_category category;return category();
}//函数的目的是为了 方便的决定某个迭代器的类型 distance type
template <class Iterator>
inline typename iterator_traits<Iterator>::difference_type *
distance_type(const Iterator&){return static_cast<typename iterator_traits<Iterator>::difference_type*>(0);
}//函数的目的是为了 方便的决定某个迭代器的类型 value type
template <class Iterator>
inline typename iterator_traits<Iterator>::value_type *
value_type(const Iterator&){return static_cast<typename iterator_traits<Iterator>::value_type*>(0);
}//整组的distance函数
template <class InputIterator>
inline typename iterator_traits<InputIterator>::difference_type
__distance(InputIterator first,InputIterator last,input_iterator_tag){typename iterator_traits<InputIterator>::difference_type n = 0;while (first != last){++first;++n;}return n;
}template <class RandomAccessIterator>
inline typename iterator_traits<RandomAccessIterator>::difference_type
__distance(RandomAccessIterator first,RandomAccessIterator last,random_access_iterator_tag){return (last - first);
}template <class InputIterator>
inline typename iterator_traits<InputIterator>::difference_type
distance(InputIterator first,InputIterator last){typedef typename iterator_traits<InputIterator>::iterator_category category;return (__distance(first,last,category()));
}//以下是整组的advance函数
template <class InputIterator,class Distance>
inline void __advance(InputIterator& i,Distance n,input_iterator_tag){while (n--){++i;}
}template <class BidirectionalIterator,class Distance>
inline void __advance(BidirectionalIterator&i,Distance n,bidirectional_iterator_tag){if (n>=0){while (n--) ++i;} else{while (n++) --i;}
}template <class RandomAccessIterator,class Distance>
inline void __advance(RandomAccessIterator& i,Distance n,random_access_iterator_tag){i+=n;
}template<class InputIterator,class Distance>
inline void advance(InputIterator& i,Distance n){__advance(i,n,iterator_category(i));
}STL源码剖析 5中迭代器型别相关推荐
- STL 源码剖析 heap堆
heap不属于STL容器的组件,属于幕后角色,是priority_queue的助手 priority_queue 允许用户以任何次序将任何元素推入容器内,但是取出的时候需要从优先级最高(也就是数值最高 ...
- C++ STL源码剖析 笔记
写在前面 记录一下<C++ STL源码剖析>中的要点. 一.STL六大组件 容器(container): 各种数据结构,用于存放数据: class template 类泛型: 如vecto ...
- 【STL源码剖析】迭代器
[STL源码剖析]迭代器 第3章 迭代器(iterators)与traits编程技法(<STL源码剖析> ) 3.1 迭代器设计思维--STL关键所在 3.2 迭代器(iterator)是 ...
- SGL STL源码剖析——迭代器
SGL STL源码剖析--迭代器 迭代器 迭代器的型别 Traits的作用 迭代器相应的五种型别 __type_traits 迭代器 在我们使用STL容器的时候,迭代器是非常常见的,STL将容器和算法 ...
- 【STL源码剖析】list模拟实现 | 适配器实现反向迭代器【超详细的底层算法解释】
今天博主继续带来STL源码剖析专栏的第三篇博客了! 今天带来list的模拟实现! 话不多说,直接进入我们今天的内容! 前言 那么这里博主先安利一下一些干货满满的专栏啦! 手撕数据结构https://b ...
- STL源码剖析 数值算法 copy 算法
copy复制操作,其操作通过使用assignment operator .针对使用trivial assignment operator的元素型别可以直接使用内存直接复制行为(使用C函数 memove ...
- STL源码剖析 算法开篇
STL源码剖析 算法章节 算法总览_CHYabc123456hh的博客-CSDN博客 质变算法 质变算法 - 会改变操作对象的数值,比如互换.替换.填写.删除.排列组合.分隔.随机重排.排序等 #in ...
- STL源码剖析 map
所有元素会根据元素的键值自动被排序 元素的类型是pair,同时拥有键值和实值:map不允许两个元素出现相同的键值 pair 代码 template <class T1,class T2> ...
- STL源码剖析 __type_traits
traits编程 弥补了C++本身的不足 STL只对迭代器进行规范制定出了iterator_traits,SGI在此基础上进一步扩展,产生了__type_traits 双下划线的含义是这个是SGI内部 ...
最新文章
- java获取vdx文件数据_通过文件名获取文件类型ContentType
- hdu1532(最大流裸题)
- Ajax和JSON-学习笔记02【JQuery方式实现Ajax】
- window.open参数完全手册
- 《统计学：从数据到结论》学习笔记(part3)--任何统计量，只要人们觉得合适就可以当成估计量
- SAP系统里的订单，可以随便删除么？
- 破旧立新 “云”称霸
- Vue父子组件传递数据
- 每日算法系列【LeetCode 287】寻找重复数
- Nginx+Tomcat实现单IP、多域名、多站点的访问
- C++_class Template about Stack(使用类模板实现栈操作)
- 创客匠人直播可同时转播10大直播平台
- Ubuntu wine 安装qq，微信
- 如何生成密钥文件Snk .
- 技术干货 | MindSpore AI科学计算系列（三）：SciML分析
- Python 文件，文件读取一行(readline)
- 第2-1课：非线性方程与牛顿迭代法
- 硕士毕业论文讨论部分怎么写啊？
- 软件测试-测试面试题
- 赔 1100 万美元！谷歌招聘年龄歧视