【设计模式学习笔记】中介者模式、观察者模式、备忘录模式案例详解（C++实现）

2023-02-08 331

版权

本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。

简介： 【设计模式学习笔记】中介者模式、观察者模式、备忘录模式案例详解（C++实现）

一、中介者模式

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. }