🚀十五、责任链模式

1.什么是责任链模式

Chain of Responsibility Pattern，CoR责任链模式，是行为型设计模式之一。责任链模式就像一个链表，将对象连成一个链式结构，并沿着这条链传递请求，直到请求被某个对象处理。在责任链模式中，客户端只要把请求放到对象链上即可，不需关心请求的传递过程和处理细节，实现了请求发送和请求处理的解耦合。

Handler：抽象处理者，定义了处理请求的接口，并包含一个指向下一个对象的指针；
ConcreteHandler：具体处理者，负责处理请求或把请求沿着对象链传递给下一个具体处理者；

2. 责任链模式案例

定义抽象处理者和具体处理者

1. class Handler
2. {
3. protected: //供子类使用
4.  Handler* next;
5. public:
6.  virtual void perform_task() = 0; //统一的任务接口
7.  Handler* set_next(Handler* next) //设置下一个要执行的任务
8.  {
9.    this->next = next;
10.     return this->next;
11.   }
12. };
13. 
14. class Task1 : public Handler
15. {
16. public:
17.   virtual void perform_task()
18.   {
19.     cout << "任务 1 执行" << endl;
20.     if (next != NULL) //如果有下一个任务，则执行
21.     {
22.       next->perform_task();
23.     }
24.   }
25. };
26. 
27. class Task2 : public Handler
28. {
29. public:
30.   virtual void perform_task()
31.   {
32.     cout << "任务 2 执行" << endl;
33.     if (next != NULL)
34.     {
35.       next->perform_task();
36.     }
37.   }
38. };
39. 
40. class Task3 : public Handler
41. {
42. public:
43.   virtual void perform_task()
44.   {
45.     cout << "任务 3 执行" << endl;
46.     if (next != NULL)
47.     {
48.       next->perform_task();
49.     }
50.   }
51. };

客户端发出请求

1. int main()
2. {
3.  Handler* task1 = NULL;
4.  Handler* task2 = NULL;
5.  Handler* task3 = NULL;
6. 
7.  task1 = new Task1;
8.  task2 = new Task2;
9.  task3 = new Task3;
10. 
11.   //任务流程：task1 -> task2 -> task3 -> 结束
12.   cout << "任务流程：task1 -> task2 -> task3 -> 结束" << endl;
13.   task1->set_next(task2);
14.   task2->set_next(task3);
15.   task3->set_next(NULL);
16. 
17.   task1->perform_task();
18.   cout << "===================================" << endl;
19. 
20.   //改变流程
21.   cout << "任务流程：task3 -> task2 -> task1 -> 结束" << endl;
22.   task1->set_next(NULL);
23.   task2->set_next(task1);
24.   task3->set_next(task2);
25. 
26.   task3->perform_task();
27.   cout << "===================================" << endl;
28. 
29.   delete task3;
30.   delete task2;
31.   delete task1;
32. 
33.   system("pause");
34.   return 0;
35. }

🚀十六、策略模式

1. 什么是策略模式

Strategy Pattern，策略模式，行为型模式之一。策略模式可以定义一个算法族，把一系列算法封装起来并提供一个统一接口，这样算法之间的切换或其他变化不会影响客户端。其关键在于，把算法的抽象接口封装在一个类中，算法的实现由具体策略类来实现，，而算法的选择由客户端决定。

Strategy：抽象策略类，定义算法族的统一接口；
ConcreteStrategy：具体策略类，实现了具体的算法操作；
Context：上下文，包含一个策略类的引用，根据不同策略执行不同操作，策略的选择由客户端决定；

2. 策略模式的案例

定义一个排序算法策略

1. class Strategy //策略
2. {
3. public:
4.  virtual void sort() = 0;
5. };
6. 
7. class SelectSort : public Strategy
8. {
9. public:
10.   virtual void sort()
11.   {
12.     cout << "选择排序算法" << endl;
13.   }
14. };
15. 
16. class InsertSort : public Strategy
17. {
18. public:
19.   virtual void sort()
20.   {
21.     cout << "插入排序算法" << endl;
22.   }
23. };

定义上下文

1. class Context
2. {
3. private:
4.  Strategy* m_strategy;
5. public:
6.  void set_strategy(Strategy* m_strategy)
7.  {
8.    this->m_strategy = m_strategy;
9.  }
10.   void execute_strategy()
11.   {
12.     this->m_strategy->sort();
13.   }
14. };

客户端选择具体排序算法

1. int main()
2. {
3.  Strategy* s1 = NULL;
4.  Context* c = NULL;
5. 
6.  c = new Context;
7. 
8.  cout << "========================" << endl;
9.  //使用选择排序算法进行排序
10.   cout << "使用选择排序算法进行排序" << endl;
11.   s1 = new SelectSort;
12.   c->set_strategy(s1);
13.   c->execute_strategy();
14.   delete s1;
15.   cout << "========================" << endl;
16. 
17.   cout << "使用插入排序算法进行排序" << endl;
18.   s1 = new InsertSort;
19.   c->set_strategy(s1);
20.   c->execute_strategy();
21.   delete s1;
22.   delete c;
23.   cout << "========================" << endl;
24. 
25.   system("pause");
26.   return 0;
27. }

🚀十七、中介者模式

1. 什么是中介者模式

Mediator Pattern，中介者模式，行为型模式之一。类与类之间的交互都放在一个中介对象中进行，即类通过中介和另一个类交互，类与类之间不用互相引用就能实现交互，降低了类与类之间的耦合。但是需要通过中介者进行交互的类中包含了中介者的引用，而中介者也包含了所有需要交互的类的引用。举例来说，比如男女相亲，男生女生之间互不相识（交互双方不需互相引用），但是他们都认识媒人（交互者包含了中介者的引用），而且没人也认识男生和女生（中介者包含了交互者的引用），再比如第三方招聘平台、招聘者、应聘者之间的关系也是这样。

Mediator：抽象中介者，定义了同事对象到中介者对象的接口；
ConcreteMediator：具体中介者，它包含了所有具体同事类的引用，并实现抽象中介类中的接口；
Colleague：抽象同事类；
ConcreteColleague：具体同事类，每个同事类只知道自己的行为，但是他们都包含中介类的引用（都认识中介）；

2.中介者模式案例

大学生通过BOOS直聘找工作，那么大学生和HR就需要通过BOOS直聘找工作，BOOS直聘就是中介，首先定义一个抽象中介类。

1. class Mediator //抽象中介者
2. {
3. public:
4.  virtual void match() = 0;
5.  virtual void set_hr(Role* hr) = 0;
6.  virtual void set_student(Role* student) = 0;
7. };

定义具体的中介BOOS直聘，大学生和公司HR通过BOOS直聘求职或招聘。

1. class Boos : public Mediator //BOOS直聘平台
2. {
3. private:
4.  Role* hr;
5.  Role* student;
6. public:
7.  virtual void set_hr(Role* hr)
8.  {
9.    this->hr = hr;
10.   }
11.   virtual void set_student(Role* student)
12.   {
13.     this->student = student;
14.   }
15.   virtual void match()
16.   {
17.     cout << "=========================" << endl;
18.     cout << hr->get_name() << " 提供职位：" << hr->get_office() << endl;
19.     cout << student->get_name() << " 需求职位：" << student->get_office() << endl;
20.     if (hr->get_office() == student->get_office())
21.     {
22.       cout << "***匹配成功***" << endl;
23.     }
24.     else
25.     {
26.       cout << "***匹配失败***" << endl;
27.     }
28.     cout << "=========================" << endl;
29.   }
30. };

定义抽象同事类，也就是需要交互的类，他应该包含一个中介类的引用，因为大学生和HR都应该认识BOOS直聘平台。

1. class Role //抽象角色
2. {
3. protected:
4.  string name;
5.  string office;
6.  Mediator* mediator;
7. public:
8.  Role(string name, string office, Mediator* mediator)
9.  {
10.     this->name = name;
11.     this->office = office;
12.     this->mediator = mediator;
13.   }
14.   string get_name()
15.   {
16.     return this->name;
17.   }
18.   string get_office()
19.   {
20.     return this->office;
21.   }
22.   virtual void match(Role* role) = 0;
23. };

定义学生类和HR类

1. class Student : public Role
2. {
3. public:
4.  Student(string name, string office, Mediator* mediator) : Role(name, office, mediator) {};
5.  virtual void match(Role* role)
6.  {
7.    mediator->set_hr(role);
8.    mediator->set_student(this);
9.    mediator->match();
10.   }
11. };
12. 
13. class HR : public Role
14. {
15. public:
16.   HR(string name, string office, Mediator* mediator) : Role(name, office, mediator) {};
17.   virtual void match(Role* role)
18.   {
19.     mediator->set_hr(this);
20.     mediator->set_student(role);
21.     mediator->match();
22.   }
23. };

大学生和HR通过BOOS进行交互

1. int main()
2. {
3. 
4.  Role* hr = NULL;
5.  Role* stu1 = NULL, * stu2 = NULL;
6.  Mediator* medi = NULL;
7. 
8.  medi = new Boos;
9. 
10.   hr = new HR("七总", "C++", medi);
11.   stu1 = new Student("小明", "Java", medi);
12.   stu2 = new Student("小红", "C++", medi);
13. 
14.   hr->match(stu1);
15.   hr->match(stu2);
16. 
17.   delete stu2;
18.   delete stu1;
19.   delete hr;
20. 
21.   system("pause");
22.   return 0;
23. }

🚀十八、观察者模式

1. 什么是观察者模式

Observer Pattern，观察者模式，行为型模式之一。观察者模式提供了一种一对多的模式，多个观察者对象同时监听一个主题对象，一旦主题对象发生变化，能够自动通知所有的观察者对象。它提供了一种关联对象之间的同步机制，他们之间通过通信来保持状态同步。

Subject：抽象主题角色，被观察的对象，当被观察的状态发生变化时，会通知所有的观察者，Subject一般包含了所有观察者对象的引用（集合）；
ConcreteSubject：具体主题，被观察者的具体实现，当状态发生改变时，向所有观察者发出通知；
Observer：抽象观察者，提供统一的接口，在得到通知时执行某些操作；
ConcreteObserver：具体观察者，实现抽象观察者提供的接口；

2. 观察者模式案例

假设两军作战，观察者为士兵

1. //观察者
2. class Soldier //士兵
3. {
4. private:
5.  Guard* guard;
6. public:
7.  Soldier(Guard* guard)
8.  {
9.    this->guard = guard;
10.   }
11.   void recv_infor(string infor)
12.   {
13.     cout << infor << ": 收到, 准备战斗" << endl;
14.   }
15. };

被观察者为哨兵，一旦发现敌军，则通知所有士兵，被观察者含有一个观察者类型的容器，用于保存所有观察者的引用。

1. class Guard //哨兵
2. {
3. private:
4.  list<Soldier*> l;
5. public:
6.  void add_observer(Soldier* soldier)
7.  {
8.    l.push_back(soldier);
9.  }
10.   void send_infor(string infor)
11.   {
12.     for (list<Soldier*>::iterator it = l.begin(); it != l.end(); it++)
13.     {
14.       (*it)->recv_infor(infor);
15.     }
16.   }
17. };

士兵收到通知，进行统一的行动，假设军队总共三个士兵

1. int main()
2. {
3.  Soldier* s1 = NULL, * s2 = NULL, * s3 = NULL;
4.  Guard* g = NULL;
5. 
6.  g = new Guard;
7.  s1 = new Soldier(g);
8.  s2 = new Soldier(g);
9.  s3 = new Soldier(g);
10. 
11.   g->add_observer(s1);
12.   g->add_observer(s2);
13.   g->add_observer(s3);
14. 
15.   string s = "敌人来了";
16.   g->send_infor(s);
17. 
18.   system("pause");
19.   return 0;
20. }

🚀十九、备忘录模式

1. 什么是备忘录模式

Memento Pattern，备忘录模式，行为型模式之一。备忘录模式在不破坏封装性的前提下，捕获一个对象的内部状态，并在外部保存，并在需要的时候恢复对象以前的状态。可以理解为，在备忘录中保存了一个对象的备份，当对象已经发生了改变，并且我们需要恢复对象以前的状态时，可以通过一个备忘录管理器来恢复以前的状态。

Originator：原生者角色，需要在备忘录中保存的对象，负责创建一个备忘录，并进行保存和恢复状态的操作；
Memento：备忘录，用于保存Originator的内部状态；
Caretaker：管理者，包含一个备忘录的引用，负责操作和管理备忘录；

2. 备忘录模式案例

定义一个备忘录

1. class Memento //备忘录
2. {
3. private:
4.  string str;
5. public:
6.  Memento(string str)
7.  {
8.    this->str = str;
9.  }
10.   string get_str()
11.   {
12.     return this->str;
13.   }
14. };

定义一个原生者

1. class Originator
2. {
3. private:
4.  string str;
5. public:
6.  void set_str(string str)
7.  {
8.    this->str = str;
9.  }
10.   Memento* get_memo()
11.   {
12.     return new Memento(this->str);
13.   }
14.   void print_str()
15.   {
16.     cout << this->str << endl;
17.   }
18.   void recover(Memento* memo)
19.   {
20.     this->str = memo->get_str();
21.   }
22. };

定义一个管理者

1. class Caretaker
2. {
3. private:
4.  Memento* memo;
5. public:
6.  void set_memo(Memento* memo)
7.  {
8.    this->memo = memo;
9.  }
10.   Memento* get_memo()
11.   {
12.     return this->memo;
13.   }
14. };

客户端测试，修改一个对象属性，并通过备忘录恢复状态

1. int main()
2. {
3.  Originator* ori = NULL;
4.  Caretaker* care = NULL;
5. 
6.  care = new Caretaker;
7. 
8.  //原始状态
9.  ori = new Originator;
10.   ori->set_str("原始状态");
11.   ori->print_str();
12.   care->set_memo(ori->get_memo());
13. 
14.   //修改状态
15.   ori->set_str("状态改变");
16.   ori->print_str();
17. 
18.   //恢复状态
19.   ori->recover(care->get_memo());
20.   ori->print_str();
21. 
22.   delete care;
23.   delete ori;
24. 
25.   system("pause");
26.   return 0;
27. }

🚀二十、访问者模式

1. 什么是访问者模式

Visitor Pattern，访问者模式，是一种行为型设计模式。访问者模式把数据结构和作用于数据结构上的操作进行了分离，在不修改已有类的前提下可以增加新的操作，而新增新的操作就相当于新增一个访问者。

Visitor：抽象访问者角色，声明了访问操作的方法，方法的参数为被访问的元素；
ConcreteVisitor：具体访问者角色，实现抽象访问者中声明的方法；
Element：抽象元素角色，声明接受访问的操作，并接收一个访问者对象作为参数；
ConcreteElement：具体元素角色，实现被访问的操作；
ObjectStructure：结构对象角色，包含一个具体元素的引用的容器；

2. 访问者模式案例

定义一个抽象访问者类和一个抽象元素类

1. class Element;
2. 
3. class Visitor //抽象访问者
4. {
5. public:
6.  virtual void visit(Element* e) = 0;
7. };
8. 
9. class Element //抽象元素
10. {
11. public:
12.   virtual void reception(Visitor* v) = 0;
13.   virtual string get_name() = 0;
14. };

以领导访问公司部门为例，创建两个公司部门

1. class Department1 : public Element //部门1
2. {
3. public:
4.  virtual void reception(Visitor* v)
5.  {
6.    v->visit(this);
7.  }
8.  virtual string get_name()
9.  {
10.     return "第一事业部";
11.   }
12. };
13. 
14. class Department2 : public Element //部门2
15. {
16. public:
17.   virtual void reception(Visitor* v)
18.   {
19.     v->visit(this);
20.   }
21.   string get_name()
22.   {
23.     return "第二事业部";
24.   }
25. };

创建访问者，董事长和部门分管领导

1. class President : public Visitor //董事长
2. {
3. public:
4.  virtual void visit(Element* e)
5.  {
6.    cout << "董事长访问：" << e->get_name() << endl;
7.  }
8. };
9. 
10. class Leader1 : public Visitor //分管领导1
11. {
12. public:
13.   virtual void visit(Element* e)
14.   {
15.     cout << "第一分管领导访问：" << e->get_name() << endl;
16.   }
17. };
18. 
19. class Leader2 : public Visitor //分管领导2
20. {
21. public:
22.   virtual void visit(Element* e)
23.   {
24.     cout << "第二分管领导访问：" << e->get_name() << endl;
25.   }
26. };

首先在客户端实现，分管部门的领导对自己的部门进行访问

1. {    
2.     v1 = new Leader1;
3.  v2 = new Leader2;
4. 
5.  e1 = new Department1;
6.  e2 = new Department2;
7. 
8.  e1->reception(v1);
9.  e2->reception(v2);
10. }

然后我们在客户端增加操作，假设董事长要来视察，因为董事长职位最大，可以对整个公司进行访问，这是可以创建一个结构对象角色，把所有的部门都包含进来

1. class Group : public Element //整个集团
2. {
3. private:
4.  list<Element*> l;
5. public:
6.  virtual void reception(Visitor* v)
7.  {
8.    for (list<Element*>::iterator it = l.begin(); it != l.end(); it++)
9.    {
10.       (*it)->reception(v);
11.     }
12.   }
13.   void add_element(Element* e)
14.   {
15.     l.push_back(e);
16.   }
17.   virtual string get_name()
18.   {
19.     return "整个集团公司";
20.   }
21. };

然后在客户端进行操作，首先把各个部门对象加入到集团公司对象中，然后董事长进行访问

1. {
2.     v = new President;
3. 
4.  e = new Group;
5.  e1 = new Department1;
6.  e2 = new Department2;
7. 
8.  //组织集团架构  加入所有部门
9.  e->add_element(e1);
10.   e->add_element(e2);
11. 
12. //董事长访问
13.   e->reception(v);
14. }

🚀二十一、状态模式

1. 什么是状态模式

State Pattern，状态模式，是一种行为型设计模式。通过改变对象的内部状态来达到改变对象行为的目的，“这个对象表现得就好像改变了它的类一样”。其实说白了就是，根据用户是输入的条件，满足一定条件就改变对象的行为，不同条件执行不同的操作。

State：抽象状态，定义了一个接口，接口声明了一个与上下文环境相关的状态的行为；
ConcreteState：具体状态，定义了本状态的行为和转换到另一个状态的判定条件；
Context：上下文、环境，负责状态的转换，包含了一个表示当前状态的State类型的引用；

2. 状态模式案例

定义状态类

1. class State
2. {
3. public:
4.  virtual void get_state(Machine* m) = 0;
5. };
6. 
7. class State1 : public State
8. {
9. public:
10.   virtual void get_state(Machine* m);
11. };
12. 
13. class State2 : public State //状态2
14. {
15. public:
16.   virtual void get_state(Machine* m);
17. };

实现状态对应行为

1. void State1::get_state(Machine* m)
2. {
3.  if (m->get_flag() == 1)
4.  {
5.    //当前状态标志是1，则执行状态1
6.    cout << "执行状态1" << endl;
7.  }
8.  else
9.  {
10.     //当前状态标志不是1，则切换为状态2
11. 
12.     //删除原来的状态
13.     delete m->get_current();
14.     //把当前状态设置为状态2
15.     m->set_flag(2);
16.     m->set_current(new State2);
17.     //执行状态
18.     m->get_current()->get_state(m);
19.   }
20. }
21. 
22. void State2::get_state(Machine* m)
23. {
24.   if (m->get_flag() == 2)
25.   {
26.     cout << "执行状态2" << endl;
27.   }
28.   else
29.   {
30.     //删除原状态
31.     delete m->get_current();
32.     //设置新的当前状态
33.     m->set_flag(1);
34.     m->set_current(new State1);
35.     //执行当前状态
36.     m->get_current()->get_state(m);
37.   }
38. }

定义一个Context类

1. class Machine
2. {
3. private:
4.  State* current; //当前状态
5.  int flag; //状态标志
6. public:
7.  State* get_current()
8.  {
9.    return this->current;
10.   }
11.   void set_current(State* s)
12.   {
13.     this->current = s;
14.   }
15.   void set_flag(int flag)
16.   {
17.     this->flag = flag;
18.   }
19.   void execute_state()
20.   {
21.     current->get_state(this);
22.   }
23.   int get_flag()
24.   {
25.     return flag;
26.   }
27. };

客户端实现状态行为的执行和转换

1. int main()
2. {
3.  Machine* m = NULL;
4.  State* s = NULL;
5. 
6.  m = new Machine;
7. 
8.  cout << "======初始状态======" << endl;
9.  //初始化为状态1
10.   s = new State1;
11.   m->set_flag(1);
12.   m->set_current(s);
13.   m->execute_state();
14. 
15.   cout << "======切换为状态2======" << endl;
16.   //切换为状态2
17.   m->set_flag(2);
18.   m->execute_state();
19. 
20.   cout << "======切换为状态1======" << endl;
21.   //切换为状态1
22.   m->set_flag(1);
23.   m->execute_state();
24. 
25.   delete s;
26.   delete m;
27. 
28.   system("pause");
29.   return 0;
30. }

🚀二十二、解释器模式

1. 什么是解释器模式

interpreter Pattern，解释器模式，是一种行为型模式。解释器模式提供一种对自定义语句的解释机制，解释器模式包含以下几种角色：

Context：解释器的上下文环境，包含了不属于解释器的其他信息；
AbstractExpression：抽象解释器，定义了一个抽象的解释操作接口；
ConcreteExpression：具体解释器，实现对相关操作的解释；

2. 解释器模式案例

定义上下文环境

1. class Context
2. {
3. private:
4.  int data;
5.  int ret;
6. public:
7.  void set_data(int data)
8.  {
9.    this->data = data;
10.   }
11.   void set_ret(int ret)
12.   {
13.     this->ret = ret;
14.   }
15.   int get_data()
16.   {
17.     return this->data;
18.   }
19.   int get_ret()
20.   {
21.     return this->ret;
22.   }
23. };

定义抽象解释器类，并实现一个加法解释器，加法解释器的操作是对传入的数据执行+1操作

1. class Expression
2. {
3. protected:
4.  Context* context;
5. public:
6.  virtual void interpret(Context* context) = 0;
7. };
8. 
9. class PlusExpression : public Expression
10. {
11.   virtual void interpret(Context* context)
12.   {
13.     int temp = context->get_data();
14.     temp++;
15.     context->set_ret(temp);
16.   }
17. };

客户端操作，向加法解释器传入一个数据，打印处理结果

1. int main()
2. {
3.  Expression* e = NULL;
4.  Context* data = NULL;
5. 
6.  e = new PlusExpression;
7.  data = new Context;
8. 
9.  data->set_data(1);
10.   cout << "原始数据：" << data->get_data() << endl;
11.   e->interpret(data);
12.   data->get_ret();
13.   cout << "经加法解释器处理后：" << data->get_ret() << endl;
14. 
15.   delete data;
16.   delete e;
17. 
18.   system("pause");
19.   return 0;
20. }

🚀二十三、迭代器模式

1. 什么是迭代器模式

Iterator Pattern，迭代器模式，是行为型模式的一种。迭代器模式提供了一种从外部遍历访问一个容器的方法，并且在不需知道容器内部细节的前提下就可以完成对容器的顺序遍历。所以，创建迭代器的容器应该将自身的引用（this指针）传递给迭代器，迭代器通过持有的这个容器的引用来实现对容器的遍历。

Iterator：迭代抽象类，用于提供实现迭代的最小方法集，一般包括获取开始对象、获取下一个对象、获取当前对象、判断是否结束这几个方法；
ConcreteIterator：具体的迭代器，实现抽象迭代器定义的方法；
Aggregate：聚集抽象类，可以理解为一个容器的接口；
ConcreteAggregate：具体聚集类，容器的实现类；

2. 迭代器模式案例

定义一个抽象的迭代器类

1. class Iterator
2. {
3. public:
4.  virtual void first() = 0;
5.  virtual void next() = 0;
6.  virtual bool is_done() = 0;
7.  virtual int current_item() = 0;
8. };

定义抽象容器类

1. class Aggregate
2. {
3. public:
4.  virtual Iterator* create_iterator() = 0;
5.  virtual int get_item(int index) = 0;
6.  virtual int get_size() = 0;
7. };

实现一个int类型的迭代器

1. class IntIterator : public Iterator
2. {
3. private:
4.  Aggregate* age;
5.  int index;
6. public:
7.  IntIterator(Aggregate* age) //迭代器应该持有一个创建迭代器的容器的引用，这样才能通过迭代器访问容器
8.  {             //谁创建迭代器就把谁的引用传递给迭代器
9.    this->age = age;
10.     this->index = 0;
11.   }
12.   virtual void first()
13.   {
14.     index = 0;
15.   }
16.   virtual void next()
17.   {
18.     if (index < age->get_size())
19.     {
20.       index++;
21.     }
22.   }
23.   virtual bool is_done()
24.   {
25.     if (index == age->get_size())
26.     {
27.       return true;
28.     }
29.     return false;
30.   }
31.   virtual int current_item()
32.   {
33.     return age->get_item(index);
34.   }
35. };

定义一个int类型的容器

1. class IntArray : Aggregate
2. {
3. private:
4.  int size;
5.  int* array;
6. public:
7.  IntArray(int size)
8.  {
9.    this->size = size;
10.     array = new int[size];
11.     for (int i = 0; i < size; i++)
12.     {
13.       array[i] = i + 1;
14.     }
15.   }
16.   ~IntArray()
17.   {
18.     if (array != NULL)
19.     {
20.       delete array;
21.       array = NULL;
22.     }
23.     this->size = 0;
24.   }
25.   virtual Iterator* create_iterator()
26.   {
27.     return new IntIterator(this); //把自己的引用传给迭代器
28.   }
29.   virtual int get_item(int index)
30.   {
31.     return array[index];
32.   }
33.   virtual int get_size()
34.   {
35.     return this->size;
36.   }
37. };

客户端，通过迭代器来遍历数组

1. int main()
2. {
3.  Iterator* it = NULL;
4.  IntArray* array = NULL;
5. 
6.  array = new IntArray(10);
7.  it = array->create_iterator();
8.  cout << "遍历数组：";
9.  for (; !(it->is_done()); it->next())
10.   {
11.     cout << it->current_item() << " ";
12.   }
13.   cout << endl;
14. 
15.   system("pause");
16.   return 0;
17. }

23个小案例带你吃透23种设计模式（三）