程序博客网 > php聚享游快乐赚源码

C++ STL迭代器

来源：互联网 发布：php聚享游快乐赚源码 编辑：程序博客网 时间：2024/06/07 02:25

一、迭代器作用

 在设计模式中有一种模式叫迭代器模式，简单来说就是提供一种方法，在不需要暴露某个容器的内部表现形式情况下，使之能依次访问该容器中的各个元素，这种设计思维在STL中得到了广泛的应用，是STL的关键所在，通过迭代器，容器和算法可以有机的粘合在一起，只要对算法给予不同的迭代器，就可以对不同容器进行相同的操作。在这里提到了一个叫迭代器的东西，说得简单一点，就是一种指针，学习C和C++的同学肯定不会对指针感到陌生，这确实是个让我们又爱又恨的东西。不曾忘记，因为指针操作引起的内存泄露、段错误而彻夜难眠；也不曾忘记，因为指针的灵活和强大，让我们自由地游刃在内存之中。以下以算法find为例，展示了容器、算法和迭代器如何合作：

[cpp] view plaincopy
  1. template<typename InputIterator, typename T>  
  2. InputIterator find(InputIterator first, InputIterator last, const T &value)  
  3. {  
  4.     while (first != last && *frist != value)  
  5.         ++first;  
  6.     return first;  
  7. }  

       从以上代码可以看到，算法通过传入的迭代器，顺序访问容器中的元素，寻找并返回符合条件的元素。通过向算法传入指向不同容器的迭代器，实现了算法以相同的逻辑对不同容器的访问。

二、 迭代器的重要特性

2.1 迭代器是一种智能指针

        与其说迭代器是一种指针，不如说迭代器是一种智能指针，它将指针进行了一层封装，既包含了原生指针的灵活和强大，也加上很多重要的特性，使其能发挥更大的作用以及能更好的使用。迭代器对指针的一些基本操作如*、->、++、==、!=、=进行了重载，使其具有了遍历复杂数据结构的能力，其遍历机制取决于所遍历的数据结构。下面上一段代码，了解一下迭代器的“智能”：

[cpp] view plaincopy
  1. template<typename T>  
  2. class Iterator  
  3. {  
  4. public:  
  5.     Iterator& operator++();  
  6.   
  7.     //...  
  8.   
  9. private:   
  10.     T *m_ptr;  
  11. };  

       对于不同的数据容器，以上Iterator类中的成员函数operator++的实现会各不相同，例如，对于数组的可能实现如下：

[cpp] view plaincopy
  1. //对于数组的实现  
  2. template<typename T>  
  3. Iterator& operator++()  
  4. {   
  5.     ++m_ptr;   
  6.     retrun *this;  
  7. }  

       对于链表，它会有一个类似于next的成员函数用于获取下一个结点，其可能实现如下：

[cpp] view plaincopy
  1. //对于链表的实现  
  2. template<typename T>  
  3. Iterator& operator++()  
  4. {  
  5.     m_ptr = m_ptr->next();//next()用于获取链表的下一个节点   
  6.     return *this;  
  7. }  

        从上面三段代码可以看到，迭代器的operator++操作对于不同数据结构，就会有不同的实现，这是C++原生所做不到的，也是迭代器为什么是一种智能指针的原因之一。看到这里，可能会有疑问，前面说迭代器针对不同的数据结构会有不同的实现，那意思是不是指迭代器一定要在数据结构内实现呢？答案是否定的，迭代器只要了解数据结构的实现，是可以在数据结构外定义，但是却有一定的代价。

2.2 不同的容器都有专属的迭代器

       下面尝试实现一个自己的迭代器，由于迭代器的作用对象是容器，因此需要首先实现一个容器，下面代码展示了一个单向链表的实现：

[cpp] view plaincopy
  1. template<typename T>  
  2. class ListItem  
  3. {  
  4. public:  
  5.     ListItem() { m_pNext = 0;}  
  6.     ListItem(T v, ListItem *p = 0) { m_value = v; m_pNext = p;}  
  7.     T Value() const { return m_value;}  
  8.     ListItem* Next() const { return m_pNext;}  
  9.       
  10. private:  
  11.     T m_value;  //存储的数据  
  12.     ListItem* m_pNext;  //指向下一个ListItem的指针  
  13. };  
  14.   
  15. template<typename T>  
  16. class List  
  17. {  
  18. public:  
  19.     //从链表尾部插入元素  
  20.     void Push(T value)  
  21.     {  
  22.        m_pTail = new ListItem<T>(value);  
  23.        m_pTail = m_pTail->Next();  
  24.     }  
  25.       
  26.     //打印链表元素  
  27.     void Print(std::ostream &os = std::cout) const  
  28.     {     
  29.         for (ListItem<T> *ptr = m_pHead; ptr; ptr = ptr->Next())  
  30.         os<<ptr->Value<<" ";  
  31.         os<<endl;  
  32.     }  
  33.       
  34.     //返回链表头部指针  
  35.     ListItem<T>* Begin() const { return m_pHead;}  
  36.   
  37.     //返回链表尾部指针  
  38.     ListItem<T>* End() const { return 0;}  
  39.       
  40.     //其它成员函数  
  41.   
  42. private：  
  43.     ListItem<T> *m_pHead;    //指向链表头部的指针  
  44.     ListItem<T> *m_pTail;    //指向链表尾部的指针  
  45.     long m_nSize;    //链表长度  
  46. };  

      下面代码展示了操作以上List容器的一个迭代器的简单实现：

[cpp] view plaincopy
  1. template<typename T>  
  2. class ListIter  
  3. {  
  4. public:  
  5.     ListIter(T *p = 0) : m_ptr(p){}  
  6.       
  7.     //解引用，即dereference  
  8.     T& operator*() const { return *m_ptr;}  
  9.       
  10.     //成员访问，即member access  
  11.     T* operator->() const { return m_ptr;}  
  12.       
  13.     //前置++操作  
  14.     ListIter& operator++()   
  15.     {   
  16.         m_ptr = m_ptr->Next(); //暴露了ListItem的东西  
  17.         return *this;  
  18.     }  
  19.       
  20.     //后置++操作  
  21.     ListIter operator++(int)  
  22.     {  
  23.         ListIter temp = *this;  
  24.         ++*this;  
  25.         return temp;  
  26.     }  
  27.       
  28.     //判断两个ListIter是否指向相同的地址  
  29.     bool opeartor==(const ListIter &arg) const { return arg.m_ptr == m_ptr;}  
  30.       
  31.     //判断两个ListIter是否指向不同的地址  
  32.     bool operator!=(const ListIter &arg) const { return arg.m_ptr != m_ptr;}  
  33.       
  34. private:  
  35.     T *m_ptr;  
  36. };  

       以下为相应的测试代码：

[cpp] view plaincopy
  1. int main(int argc, const char *argv[])  
  2. {  
  3.     List<int> mylist;  
  4.       
  5.     for (int i = 0; i < 5; ++i)  
  6.     {  
  7.         mylist.push(i);  
  8.     }  
  9.     mylist.Print(); //0 1 2 3 4  
  10.       
  11.     //暴露了ListItem  
  12.     ListIter<ListItem<int> > begin(mylist.Begin());  
  13.     ListIter<ListItem<int> > end(mylist.End());  
  14.     ListIter<ListItem<int> > iter;  
  15.       
  16.     iter = find(begin, end, 3);//从链表中查找3  
  17.     if (iter != end)  
  18.         cout<<"found"<<endl;  
  19.     else  
  20.         cout<<"not found"<<endl;  
  21. }  

     上面使用迭代器的测试代码给人的第一感觉就是好麻烦，首先需要声明和定义了begin和end两个ListIter<ListItem<int> >类型的迭代器，分别用来标识所操作容器List的头部和尾部，这时候暴露了ListItem；在ListIter的实现中，为了实现operator++的功能，我们又暴露了ListItem的函数Next()。另外，细心的你可能发现，算法find是通过*first != value用来判断元素是否符合要求，而上面测试代码中，first的类型为ListItem<int>，而value的类型为int，两者之间并没有可用的operator!=函数，因此，需要另外声明一个全局的operator!=重载函数，代码如下：

[cpp] view plaincopy
  1. template<typename T>  
  2. bool operator!=(const ListItem<T> &item, T n)  
  3. {  
  4.     return item.Value() != n;  
  5. }  

     为了实现迭代器ListIter，我们在很多地方暴露了容器List的内部实现ListItem，这违背一开始说的迭代器模式中不暴露某个容器的内部表现形式情况下，使之能依次访问该容器中的各个元素的定义。为了解决这种问题，STL将迭代器的实现交给了容器，每种容器都会以嵌套的方式在内部定义专属的迭代器。各种迭代器的接口相同，内部实现却不相同，这也直接体现了泛型编程的概念。

三、迭代器的分类

     在STL中，原生指针也是一种迭代器，除了原生指针以外，迭代器被分为五类：

  • Input Iterator
          此迭代器不允许修改所指的对象，即是只读的。支持==、!=、++、*、->等操作。
  • Output Iterator
          允许算法在这种迭代器所形成的区间上进行只写操作。支持++、*等操作。
  • Forward Iterator
          允许算法在这种迭代器所形成的区间上进行读写操作，但只能单向移动，每次只能移动一步。支持Input Iterator和Output Iterator的所有操作。
  • Bidirectional Iterator
          允许算法在这种迭代器所形成的区间上进行读写操作，可双向移动，每次只能移动一步。支持Forward Iterator的所有操作，并另外支持--操作。
  • Random Access Iterator
          包含指针的所有操作，可进行随机访问，随意移动指定的步数。支持前面四种Iterator的所有操作，并另外支持it + n、it - n、it += n、 it -= n、it1 - it2和it[n]等操作。

     迭代器的分类和继承体系可用下面的图表示：

    
 

    为什么要将迭代器分为这五类，而且为什么要将它们设计为这种继承体系呢？在学习C++继承的时候，我们知道，位置继承体系越后的类，功能越强大，但是考虑的东西也会越多，体型也会越臃肿。为了提供最大化的执行效率，STL在设计算法时，会尽量提供一个最明确最合适的迭代器，在完成任务的同时，也尽量提高算法的效率。假设有个算法可接受Forward Iterator，此时，你可以传入一个Random Access Iterator，因为Random Access Iterator也是一种Forward Iterator，但是可用并不代表最合适，我们只需要Forward Iterator的功能，却传入了更多属于Random Access Iterator的在这里没有用到的功能，一定程度上会降低了算法的效率。

    以函数advance为例，说明这种迭代器分类和继承体系的好处，此函数有两个参数，分别是迭代器i和数值n，主要作用是将i前进n距离，下面会有advance函数的三份定义，一份是针对Input Iterator，一份针对Bidirectional Iterator，另一份针对Random Access Iterator，而针对Forward Iterator的实现和针对Input Iterator的实现是一样的，因此没有单独列出，代码如下：

[cpp] view plaincopy
  1. template<typename InputIterator, typename Distance>  
  2. void advance_II(InputIterator &i, Distance n)  
  3. {  
  4.     //单向逐一前进  
  5.     while (n--) ++i;  
  6. }  
  7.   
  8. template<typename BidirectionalIterator, typename Distance>  
  9. void advance_BI(BidirectionalIterator &i, Distance n)  
  10. {  
  11.     //双向逐一前进  
  12.     if (n >= 0)  
  13.       while (n--) ++i;  
  14.     else  
  15.       while (n++) --i;  
  16. }  
  17.   
  18. template<typename RandomAccessIterator, typename Distance>  
  19. void advance_RAI(RandomAccessIterator &i, Distance n)  
  20. {  
  21.     //双向跳跃前进  
  22.     i += n;  
  23. }  

       对于Random Access Iterator来说，当程序调用advance_RAI函数时，只需O(1)的时间复杂度；当程序调用advance_II()函数时，操作非常缺乏效率，原本只需O(1)时间复杂度的操作竟然变成为O(N)。因此，为了最大限度提高效率，STL将迭代器进行了明确的分类，同时将其设计为一种继承关系，以提高算法的可用性，如果某个迭代器没有相应版本的算法，通过类型转换，可以使用父类版本的算法，尽管效率不一定最优，但至少可用。

四、迭代器的使用实例

       前面说了这么多，下面简单展示一下迭代器的使用：

[cpp] view plaincopy
  1. #include <iostream>  
  2. #include <vector>  
  3. #include <list>  
  4. #include <algorithm>  
  5. using namespace std;  
  6.   
  7. int main(int argc, const char *argv[])  
  8. {  
  9.     int arr[5] = { 1, 2, 3, 4, 5};  
  10.    
  11.     vector<int> iVec(arr, arr + 5);//定义容器vector  
  12.     list<int iList(arr, arr + 5);//定义容器list  
  13.   
  14.     //在容器iVec的头部和尾部之间寻找整形数3  
  15.     vector<int>::iterator iter1 = find(iVec.begin(), iVec.end(), 3);  
  16.     if (iter1 == iVec.end())  
  17.         cout<<"3 not found"<<endl;  
  18.     else  
  19.         cout<<"3 found"<<endl;  
  20.   
  21.     //在容器iList的头部和尾部之间寻找整形数4  
  22.     list<int>::iterator iter2 = find(iList.begin(), iList.end(), 4);  
  23.     if (iter2 == iList.end())  
  24.         cout<<"4 not found"<<endl;  
  25.     else  
  26.         cout<<"4 found"<<endl;  
  27.   
  28.     return 0;  
  29. }  

       从上面迭代器的使用中可以看到，迭代器依附于具体的容器，即不同的容器有不同的迭代器实现，同时，我们也看到，对于算法find来说，只要给它传入不同的迭代器，即可对不同的容器进行查找操作。通过迭代器的穿针引线，有效地实现了算法对不同容器的访问，这也是迭代器的设计目的

0 0
php聚享游快乐赚源码 php聚享游快乐赚源码
原创粉丝点击
热门IT博客
刘裕 知乎刘裕 知乎
知乎客服知乎客服
网络qos管理
服务中没有sql server
steam淘宝喜加一
360云盘for mac
cf雷神刀伤害数据
淘宝买家怎样开店
桌面天气预报软件
java泛型集合
清单计价软件免费
皮肤 微生物 知乎
日本三河黑松淘宝网
大数据图片素材
证券时报 数据宝下载
人工智能是什么意思
下载床上交友软件
紫鸟数据库
领航一号软件下载
大数据用户画像 模型
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 釉上彩瓷器鉴定 唇釉可以带上飞机吗 釉 上野真奈美 上野树里 ig上野矛盾 ig上野 上野奈津日 上野公园 上野 上野结 上野莉奈 上野裕马 上野美咲 上野美帆 上野动物园 上野结衣 01上野树里 上野真奈美在线插播放 大雄上野比玉子第六章 上野真奈美作品一览 上野真奈美作品集封面 上野恩赐公园旅游 上野真奈美在线播放 上野树里 樱花 笨拙至极的上野同学 上野原日语培训中心 笨拙之极的上野 新垣结衣 上野树里 东京上野酒店 上野树里歌曲 上胸围下胸围怎么量 卫生巾上月经量参照图 抖音浏览量上不去 海水不可斗量的上一句 月经量比上个月少是什么原因 量, 量 有量 量一量 量量

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里