设计模式笔记--行为型模式之四-Iterator

意图：

提供一种方法顺序访问一个聚合对象中各个元素，而又不需要暴露该对象的内部表示。

 

 

适用性：

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

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

3为遍历不同的聚合结构提供一个统一的接口

效果：

1它支持以不同的方式遍历一个聚合

2简化聚合的接口

3在同一个聚合上可以有多个遍历

 

实现：

1谁控制该迭代 

当客户来控制该迭代时，该迭代器称为外部迭代器。客户主动的推进遍历的步伐。

当由迭代器内部控制迭代时，该迭代器称为外部迭代器。客户只需要提交一个待执行的操作，而迭代器将对聚合中的每一个元素实施该操作

2谁定义遍历算法

聚合本身可以定义遍历算法

迭代器负责遍历算法，易于在相同的聚合上使用不同的迭代算法，也易于在不同的聚合上重用相同的算法

3迭代器的健壮性 一个健壮的迭代器保证插入和删除操作不会干扰遍历，且不需拷贝该聚合

4附加的迭代器操作 迭代器的最小接口由First,Next,IsDone和CurrentItem组成，可附加一些其他可用的操作。

5在C++中使用多态的迭代器  用一个Factory Method动态的分配迭代器对象。

多态迭代器有一个缺点：客户必须负责删除它们，有一个补救方法是，适用一个栈分配的Proxy作为实际迭代器的中间代理，该代理在其析构器中删除该迭代器

 

Interator.h

 

1. #include <iostream>
2. using namespace std;
4. class Employee
5. {
6. public:
7.     Employee(const char* name,int age):_name(name),_age(age){}
8.     ~Employee(){cout<<"An employee is destroyed"<<endl;}
9.     void print(){cout<<"The employee name is "<<_name<<" and the age is "<<_age<<endl;}
10. private:
11.     const char* _name;
12.     int _age;
14. };
16. template <class Item>
17. class List
18. {
19. public:
20.     List(long size = 0):_size(size)
21.     {
22.      cout<<"A list is created"<<endl;
23.     }
24.     long Count() const {return _size;}
25.     
26.     
27.     typedef struct Node
28.     {
29.      
30.         Node(){}
31.         Item item;
32.         Node* next;
33.         Node* prev;
35.     } Node;
36.     Item Get(long index) const
37.     {
38.         long i =0;
39.         Node*   p = itemlist;
40.         for (i =0;i<index;i++)
41.             p = p->next;
42.         return (p->item);
44.     }
45.     Node* End() const
46.     {
47.       Node* p = itemlist;
48.       if ((p->next == NULL)&&(p->prev == NULL))
49.           return p;
51.         while(p->next != NULL)
52.         {
53.             p= p->next;
54.         }
55.         return p;
56.     }
57.     void Append(const Item& item)
58.     {
59.         //Node* end = End();
60.         Node* a = new Node;
62.         a->item = item;
63.         a->next = NULL;
64.         if (_size == 0)
65.         {
66.             a->prev = NULL;
67.             itemlist = a;
68.         }
69.         else
70.         {
71.         End()->next = a;
72.         a->prev = End();
73.         }
74.         _size ++;
75.     }
76. private:
77.     long _size;
78.     
79.     Node* itemlist;
80. };
83. template <class Item>
84. class Iterator
85. {
86. public:
87.     virtual void First() = 0;
88.     virtual void Next() = 0;
89.     virtual bool IsDone() const=0;
90.     virtual Item CurrentItem() const=0;
91. protected:
92.     Iterator(){}
93. };
96. template <class Item>
97. class ListIterator:public Iterator<Item>
98. {
99. public:
100.     ListIterator(List <Item>* aList)
101.   {
102.     _list = aList;
103.     _current = 0;
104. }
105.     virtual void First() {_current=0;}
106.     virtual void Next() {_current++;}
107.     virtual bool IsDone() const 
108.     {   return _current >= _list->Count();}
109.   virtual Item CurrentItem() const
110.   {
111.         if (IsDone())
112.     {
113.         return 0;
114.     }
115.     else
116.         return _list->Get(_current);
117.   }
118. private:
119.   List<Item>* _list;
120.   long _current;
121. };

 

main.cpp

1. #include "Iterator.h"
2. #include <iostream>
3. using namespace std;
5. void PrintEmployees(ListIterator<Employee*>& i)
6. {
7.     for(i.First();!i.IsDone();i.Next())
8.         if (i.CurrentItem()!= 0)
9.             (i.CurrentItem())->print();
10. }
11. int main()
12. {
13.     List<Employee*>* employees = new List<Employee*>;
14.     Employee* e1= new Employee("11",11);
15.     Employee* e2 = new Employee("22",22);
16.     employees->Append(e1);
17.     employees->Append(e2);
18.     ListIterator<Employee*> forward(employees);
19.     //ListIterator<Employee*>* forward;
20.     //forward = new ListIterator<Employee*>(employees);
21.     
22.     PrintEmployees(forward);
24.     List<int> a;
25.     int  b =1;
26.     int c=1;
27.     a.Append(b);
28.     a.Append(c);
29.     return 0;
30. }