设计模式之迭代器模式

1、迭代器模式（Iterator）：提供一种方法顺序访问一个聚合对象中各个元素，而不是暴露该对象的内部表示。

2、一个聚集对象，而且不管这些对象是什么都需要遍历的时候，你就应该考虑用迭代器模式。你需要对聚集有多种方式遍历时，可以考虑用迭代器模式。为遍历不同的聚集结构提供如开始，下一个，是否结束，当前哪一项等统一的接口。

UML图如下：

参与者：

Iterator

----迭代器定义访问和遍历元素的接口。

ConcreteIterator

----具体迭代器实现迭代器接口

----对该聚合遍历时跟踪当前位置。

Aggregate（聚合）

----聚合定义创建相应迭代器对象的接口

ConcreteAggregate（具体聚合）

----具体聚合实现创建相应的迭代器接口，该操作返回ConcreteIterator的一个适当的实例。

协作：

----ConcreteIterator跟踪聚合中的当前对象，并能够计算出待遍历的后继对象。

3、当你需要对聚集有多种遍历方式时，可以考虑用迭代器模式。迭代器模式(Iterator)就是分离了集合对象的遍历行为，抽象为一个迭代器类来负责，这样即可以做到不暴露集合的内部结构，又可让外部代码透明地访问集合内部的数据。

4、C++代码实现

[cpp] view plaincopy

 

1. #include <iostream>  
2. #include <string>  
3. #include <vector>  
4. using namespace std;  
5.   
6. /* 迭代器抽象类  */  
7. class Iterator  
8. {  
9. public:  
10.     virtual string First() = 0;  
11.     virtual string Next() = 0;  
12.     virtual bool IsDone() = 0;  
13.     virtual string CurrentItem() = 0;  
14. };  
15.   
16. /* Aggregate聚集抽象类 */  
17. class Aggregate  
18. {  
19. public:  
20.     virtual Iterator * CreateIterator() = 0;  
21. };  
22.   
23. /* 具体聚集类，继承Aggregate  */  
24. class ConcreteAggregate : public Aggregate  
25. {  
26. private:  
27.     vector<string> v;  
28. public:  
29.     /*  创建迭代器  */  
30.     Iterator * CreateIterator();  
31.     int Count();  
32.     string & operator[](int);  
33. };  
34.   
35. /*  ConcreteIterator具体迭代器类，继承Iterator */  
36. class ConcreteIterator : public Iterator  
37. {  
38. private:  
39.     /*  定义一个具体聚集对象 */  
40.     ConcreteAggregate * p_aggregate;  
41.     int current;  
42. public:  
43.     /* 初始化时候将具体的聚集对象传入 */  
44.     ConcreteIterator(ConcreteAggregate *);  
45.     string First();  
46.     string Next();  
47.     bool IsDone();  
48.     string CurrentItem();  
49. };  
50.   
51. ConcreteIterator::ConcreteIterator(ConcreteAggregate * p_aggregate)  
52. {  
53.     ConcreteIterator::p_aggregate = p_aggregate;  
54.     current = 0;  
55. }  
56.   
57. /* 得到聚集的第一个对象 */  
58. string ConcreteIterator::First() {  
59.     return (*p_aggregate)[0];  
60. }  
61.   
62. /*  得到聚集的下一个对象 */  
63. string ConcreteIterator::Next() {  
64.     string p = "";  
65.     current++;  
66.     if (current < p_aggregate->Count()) {  
67.         p = p_aggregate->operator [](current);  
68.     }  
69.     return p;  
70. }  
71.   
72. /* 判断当前是否遍历到结尾，到结尾返回true。 */  
73. bool ConcreteIterator::IsDone()  
74. {  
75.     return current >= p_aggregate->Count() ? true : false;  
76. }  
77.   
78. string ConcreteIterator::CurrentItem() {  
79.     return p_aggregate->operator [](current);  
80. }  
81.   
82. Iterator * ConcreteAggregate::CreateIterator()  
83. {  
84.     return new ConcreteIterator(this);  
85. }  
86.   
87. int ConcreteAggregate::Count()  
88. {  
89.     return v.size();  
90. }  
91.   
92. string& ConcreteAggregate::operator [](int index) {  
93.     if (index >= v.size()) {  
94.         v.push_back("empty");  
95.     }  
96.     return v[index];  
97. }  
98.   
99. int main()  
100. {  
101.     ConcreteAggregate aggregate;  
102.     string a = "大鸟";  
103.     string b = "小菜";  
104.     string c = "行李";  
105.     string d = "老外";  
106.     string e = "公交内部人员";  
107.     string f = "小偷";  
108.     aggregate[0] = a;  
109.     aggregate[1] = b;  
110.     aggregate[2] = c;  
111.     aggregate[3] = d;  
112.     aggregate[4] = e;  
113.     aggregate[5] = f;  
114.   
115.     Iterator * it = aggregate.CreateIterator();  
116.     string p_item = it->First();  
117.     while (!it->IsDone()) {  
118.         cout << it->CurrentItem() << " 请买车票！" << endl;  
119.         it->Next();  
120.     }  
121.     return 0;  
122. }