一、中介者模式
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. }
