设计模式之迭代器

概述：

        在现在的电视机中，我们使用[后一个]和[前一个]按钮可以很方便的换台，当按下[后一个]按钮时，将切换到下一个预置的频道。想象一下在陌生的城市中的旅店中看电视。当改变频道时，重要的不是几频道，而是节目内容。如果对一个频道的节目不感兴趣，那么可以换下一个频道，而不需要知道它是几频道。

        这个其实就是我们迭代器模式的精髓：提供一种方法顺序访问一个聚合对象中各个元素, 而又不需暴露该对象的内部表示。

类图和实例：

迭代器模式由以下角色组成：

1．迭代器角色（Iterator）：迭代器角色负责定义访问和遍历元素的接口。
2．具体迭代器角色（Concrete Iterator）：具体迭代器角色要实现迭代器接口，并要记录遍历中的当前位置。
3．集合角色（Aggregate）：集合角色负责提供创建具体迭代器角色的接口。
4．具体集合角色（Concrete Aggregate）：具体集合角色实现创建具体迭代器角色的接口——这个具体迭代器角色于该集合的结构相关。

[cpp] view plain copy

print ?

1. #include <iostream>  
2. #include <vector>  
3. using namespace std;  
4.   
5. template<class Item>  
6. class Iterator  
7. {  
8. public:  
9.     virtual void first()=0;  
10.     virtual void next()=0;  
11.     virtual Item* currentItem()=0;  
12.     virtual bool isDone()=0;  
13.     virtual ~Iterator(){}  
14. };  
15.   
16. template<class Item>  
17. class ConcreteAggregate;  
18.   
19. template<class Item>  
20. class ConcreteIterator : public Iterator <Item>  
21. {  
22.     ConcreteAggregate<Item> * aggr;  
23.     int cur;  
24. public:  
25.     ConcreteIterator(ConcreteAggregate<Item>*a):aggr(a),cur(0){}  
26.     virtual void first()  
27.     {  
28.         cur=0;  
29.     }  
30.     virtual void next()  
31.     {  
32.         if(cur<aggr->getLen())  
33.             cur++;  
34.     }  
35.     virtual Item* currentItem()  
36.     {  
37.         if(cur<aggr->getLen())  
38.             return &(*aggr)[cur];  
39.         else  
40.             return NULL;  
41.     }  
42.     virtual bool isDone()  
43.     {  
44.         return (cur>=aggr->getLen());  
45.     }  
46. };  
47.   
48. template<class Item>  
49. class Aggregate  
50. {  
51. public:  
52.     virtual Iterator<Item>* createIterator()=0;  
53.     virtual ~Aggregate(){}  
54. };  
55.   
56. template<class Item>  
57. class ConcreteAggregate:public Aggregate<Item>  
58. {  
59.     vector<Item >data;  
60. public:  
61.     ConcreteAggregate()  
62.     {  
63.         data.push_back(1);  
64.         data.push_back(2);  
65.         data.push_back(3);  
66.     }  
67.     virtual Iterator<Item>* createIterator()  
68.     {  
69.         return new ConcreteIterator<Item>(this);  
70.     }  
71.     Item& operator[](int index)  
72.     {  
73.         return data[index];  
74.     }  
75.     int getLen()  
76.     {  
77.         return data.size();  
78.     }  
79. };  
80.   
81. int main()  
82. {  
83.     Aggregate<int> * aggr =new ConcreteAggregate<int>();  
84.     Iterator<int> *it=aggr->createIterator();  
85.   
86.     for(it->first();!it->isDone();it->next())  
87.     {  
88.         cout<<*(it->currentItem())<<endl;  
89.     }  
90.     delete it;  
91.     delete aggr;  
92.     return 0;  
93. }  

#include <iostream>

#include <vector> using namespace std; template<class Item> class Iterator { public: virtual void first()=0; virtual void next()=0; virtual Item* currentItem()=0; virtual bool isDone()=0; virtual ~Iterator(){} }; template<class Item> class ConcreteAggregate; template<class Item> class ConcreteIterator : public Iterator <Item> { ConcreteAggregate<Item> * aggr; int cur; public: ConcreteIterator(ConcreteAggregate<Item>*a):aggr(a),cur(0){} virtual void first() { cur=0; } virtual void next() { if(cur<aggr->getLen()) cur++; } virtual Item* currentItem() { if(cur<aggr->getLen()) return &(*aggr)[cur]; else return NULL; } virtual bool isDone() { return (cur>=aggr->getLen()); } }; template<class Item> class Aggregate { public: virtual Iterator<Item>* createIterator()=0; virtual ~Aggregate(){} }; template<class Item> class ConcreteAggregate:public Aggregate<Item> { vector<Item >data; public: ConcreteAggregate() { data.push_back(1); data.push_back(2); data.push_back(3); } virtual Iterator<Item>* createIterator() { return new ConcreteIterator<Item>(this); } Item& operator[](int index) { return data[index]; } int getLen() { return data.size(); } }; int main() { Aggregate<int> * aggr =new ConcreteAggregate<int>(); Iterator<int> *it=aggr->createIterator(); for(it->first();!it->isDone();it->next()) { cout<<*(it->currentItem())<<endl; } delete it; delete aggr; return 0; }

实现要点：

1．迭代抽象：访问一个聚合对象的内容而无需暴露它的内部表示。

2．迭代多态：为遍历不同的集合结构提供一个统一的接口，从而支持同样的算法在不同的集合结构上进行操作。

3．迭代器的健壮性考虑：遍历的同时更改迭代器所在的集合结构，会导致问题。

适用性：

1．访问一个聚合对象的内容而无需暴露它的内部表示。 

2．支持对聚合对象的多种遍历。 

3．为遍历不同的聚合结构提供一个统一的接口(即, 支持多态迭代)。

其他：

1．在C++下可以参看 STL iterators 的实现。

2．在.NET下实现Iterator模式，对于聚集接口和迭代器接口已经存在了，其中IEnumerator扮演的就是迭代器的角色，而IEnumerable则扮演的就是抽象聚集的角色，她只有一个GetEnumerator()方法，如果集合对象需要具备跌代遍历的功能，就必须实现该接口。

3．在Java下可以参看集合类型迭代器（java.util.Iterator，java.util.Enumeration）。

LCL_data原创于优快云.NET【http://blog.youkuaiyun.com/lcl_data/article/details/9310313】

其他设计模式请参看：我所理解的设计模式

document.getElementById("bdshell_js").src = "http://bdimg.share.baidu.com/static/js/shell_v2.js?cdnversion=" + Math.ceil(new Date()/3600000)

    <div id="digg" articleid="9310313">
        <dl id="btnDigg" class="digg digg_enable" onclick="btndigga();">

             <dt>顶</dt>
            <dd>10</dd>
        </dl>


        <dl id="btnBury" class="digg digg_enable" onclick="btnburya();">

              <dt>踩</dt>
            <dd>0</dd>               
        </dl>

    </div>
 <div class="tracking-ad" data-mod="popu_222"><a href="javascript:void(0);" target="_blank">&nbsp;</a>   </div>
<div class="tracking-ad" data-mod="popu_223"> <a href="javascript:void(0);" target="_blank">&nbsp;</a></div>
<script type="text/javascript">
    function btndigga() {
        $(".tracking-ad[data-mod='popu_222'] a").click();
    }
    function btnburya() {
        $(".tracking-ad[data-mod='popu_223'] a").click();
    }
        </script>

•