1. 中介者模式: 用一个中介对象来封装一系列的对象交互,中介者使各对象不需要显式地相互引用,从而使其耦合松散,而且可以独立改变他们之间的交互。

Mediator的出现减少了各个Colleague的耦合,使得可以独立地改变和复用各个Colleague类和Mediator.

由于ConcreteMediator控制了集中化,于是就把交互复杂性变为了中介者的复杂性,这就使得中介者变为比任何一个ConcreteColleague都复杂。

中介者模式一般应用于一组对象以定义良好但复杂的方式进行通信的场合,以及想定制一个分部在多个类中的行为,而又不想生成太多的子类的场合。

实例:

colleague.h colleague.cpp

  1. #ifndef COLLEAGUE_H
  2. #define COLLEAGUE_H
  3.  
  4. class Mediator;
  5.  
  6. class Colleague
  7. {
  8. public:
  9. Colleague(Mediator *mediator);
  10.  
  11. protected:
  12. Mediator *mediator;
  13. };
  14.  
  15. #endif // COLLEAGUE_H
  1. #include "colleague.h"
  2. #include "mediator.h"
  3.  
  4. Colleague::Colleague(Mediator *mediator)
  5. {
  6. this->mediator = mediator;
  7. }

concretecolleague1.h concretecolleague1.cpp

  1. #ifndef CONCRETECOLLEAGUE1_H
  2. #define CONCRETECOLLEAGUE1_H
  3.  
  4. #include "colleague.h"
  5. #include "mediator.h"
  6. #include <string>
  7. using namespace std;
  8.  
  9. class ConcreteColleague1 : public Colleague
  10. {
  11. public:
  12. ConcreteColleague1(Mediator *mediator);
  13. void send(string message);
  14. void notify(string message);
  15. };
  16.  
  17. #endif // CONCRETECOLLEAGUE1_H
  1. #include "concretecolleague1.h"
  2. #include <iostream>
  3. using namespace std;
  4.  
  5. ConcreteColleague1::ConcreteColleague1(Mediator *mediator) : Colleague(mediator)
  6. {
  7. }
  8.  
  9. void ConcreteColleague1::send(string message)
  10. {
  11. mediator->send(message, this);
  12. }
  13.  
  14. void ConcreteColleague1::notify(string message)
  15. {
  16. cout << "Colleague1 get a message: " << message << endl;
  17. }

concretecolleague2.h concretecolleague2.cpp

  1. #ifndef CONCRETECOLLEAGUE2_H
  2. #define CONCRETECOLLEAGUE2_H
  3.  
  4. #include "colleague.h"
  5. #include "mediator.h"
  6. #include <string>
  7. using namespace std;
  8.  
  9. class ConcreteColleague2 : public Colleague
  10. {
  11. public:
  12. ConcreteColleague2(Mediator *mediator);
  13. void send(string message);
  14. void notify(string message);
  15. };
  16.  
  17. #endif // CONCRETECOLLEAGUE2_H
  1. #include "concretecolleague2.h"
  2. #include <iostream>
  3. using namespace std;
  4.  
  5. ConcreteColleague2::ConcreteColleague2(Mediator *mediator) : Colleague(mediator)
  6. {
  7. }
  8.  
  9. void ConcreteColleague2::send(string message)
  10. {
  11. mediator->send(message, this);
  12. }
  13.  
  14. void ConcreteColleague2::notify(string message)
  15. {
  16. cout << "Colleague2 get a message: " << message << endl;
  17. }

mediator.h mediator.cpp

  1. #ifndef MEDIATOR_H
  2. #define MEDIATOR_H
  3.  
  4. #include "colleague.h"
  5. #include <string>
  6. using namespace std;
  7.  
  8. class Mediator
  9. {
  10. public:
  11. Mediator();
  12. void virtual send(string message, Colleague *colleague)=0;
  13. };
  14.  
  15. #endif // MEDIATOR_H
  1. #include "mediator.h"
  2.  
  3. Mediator::Mediator()
  4. {
  5. }

concretemediator.h concretemediator.cpp

  1. #ifndef CONCRETEMEDIATOR_H
  2. #define CONCRETEMEDIATOR_H
  3.  
  4. #include "mediator.h"
  5. #include "concretecolleague1.h"
  6. #include "concretecolleague2.h"
  7.  
  8. class ConcreteMediator : public Mediator
  9. {
  10. public:
  11. ConcreteMediator();
  12. void setcolleague1(ConcreteColleague1 *colleague);
  13. void setcolleague2(ConcreteColleague2 *colleague);
  14. void send(string message, Colleague *colleague);
  15.  
  16. private:
  17. ConcreteColleague1 *colleague1;
  18. ConcreteColleague2 *colleague2;
  19. };
  20.  
  21. #endif // CONCRETEMEDIATOR_H
  1. #include "concretemediator.h"
  2.  
  3. ConcreteMediator::ConcreteMediator()
  4. {
  5. }
  6.  
  7. void ConcreteMediator::send(string message, Colleague *colleague)
  8. {
  9. if( colleague == colleague1 )
  10. colleague2->notify(message);
  11. else
  12. colleague1->notify(message);
  13.  
  14. }
  15.  
  16. void ConcreteMediator::setcolleague1(ConcreteColleague1 *colleague)
  17. {
  18. this->colleague1 = colleague;
  19. }
  20.  
  21. void ConcreteMediator::setcolleague2(ConcreteColleague2 *colleague)
  22. {
  23. this->colleague2 = colleague;
  24. }

main.cpp

  1. #include <iostream>
  2. #include "concretecolleague1.h"
  3. #include "concretecolleague2.h"
  4. #include "concretemediator.h"
  5. using namespace std;
  6.  
  7. int main()
  8. {
  9. cout << "Mediator test!" << endl;
  10.  
  11. ConcreteMediator *m = new ConcreteMediator();
  12. ConcreteColleague1 *c1 = new ConcreteColleague1(m);
  13. ConcreteColleague2 *c2 = new ConcreteColleague2(m);
  14. m->setcolleague1(c1);
  15. m->setcolleague2(c2);
  16. c1->send("I come from C1, how are you? ");
  17. c2->send("I come from C2, I am fine. ");
  18.  
  19. return 0;
  20. }

大话设计模式--中介者模式 Mediator --C++实现实例的更多相关文章

  1. 设计模式-中介者模式(Mediator)

    场景分析: 众所周知,电脑有很多组成部分,如硬盘.内存.光驱.音频.键盘等,各个组件之间协同工作才能保证电脑的正常运行. 如果各个组件之间直接交互,可能会比较复杂,如下图: 将上面的各个组件抽象成类, ...

  2. 23种设计模式--中介者模式-Mediator Pattern

    一.中介者模式的介绍     中介者模式第一下想到的就是中介,房子中介,婚姻中介啊等等,当然笔者也希望来个婚姻中介给我介绍一个哈哈哈,,回归正题中介者模式分成中介者类和用户类,根据接口编程的方式我们再 ...

  3. 大话设计模式--享元模式 Flyweight -- C++实现实例

    1. 享元模式: 运用共享技术有效地支持大量细粒度的对象. 享元模式可以避免大量非常相似类的开销,在程序设计中,有时需要生成大量颗粒度的类实例来表示数据,如果能发现这些实例除了几个参数外基本都是相同的 ...

  4. 大话设计模式--装饰者模式 Decorator -- C++实现实例

    1.装饰者模式 Decorator 动态地给一个对象添加一个额外的职责, 就添加功能来说, 装饰模式比生成子类更为灵活. 每个装饰对象的实现和如何使用这个对象分离,  每个装饰对象只关心自己的功能,不 ...

  5. 深入浅出设计模式——中介者模式(Mediator Pattern)

    模式动机 在用户与用户直接聊天的设计方案中,用户对象之间存在很强的关联性,将导致系统出现如下问题: 系统结构复杂:对象之间存在大量的相互关联和调用,若有一个对象发生变化,则需要跟踪和该对象关联的其他 ...

  6. 【转】设计模式 ( 十五 ) 中介者模式Mediator(对象行为型)

    设计模式 ( 十五 ) 中介者模式Mediator(对象行为型) 1.概述 在面向对象的软件设计与开发过程中,根据"单一职责原则",我们应该尽量将对象细化,使其只负责或呈现单一的职 ...

  7. 设计模式 ( 十五 ) 中介者模式Mediator(对象行为型)

    设计模式 ( 十五 ) 中介者模式Mediator(对象行为型) 1.概述 在面向对象的软件设计与开发过程中,根据“单一职责原则”,我们应该尽量将对象细化,使其只负责或呈现单一的职责,即将行为分布到各 ...

  8. 乐在其中设计模式(C#) - 中介者模式(Mediator Pattern)

    原文:乐在其中设计模式(C#) - 中介者模式(Mediator Pattern) [索引页][源码下载] 乐在其中设计模式(C#) - 中介者模式(Mediator Pattern) 作者:weba ...

  9. 设计模式系列之中介者模式(Mediator Pattern)——协调多个对象之间的交互

    说明:设计模式系列文章是读刘伟所著<设计模式的艺术之道(软件开发人员内功修炼之道)>一书的阅读笔记.个人感觉这本书讲的不错,有兴趣推荐读一读.详细内容也可以看看此书作者的博客https:/ ...

随机推荐

  1. lua string库

      --lua中字符串索引从前往后是1,2,……,从后往前是-1,-2……. --string库中所有的function都不会直接操作字符串,只返回一个结果. -------------------- ...

  2. java多线程编码注意事项

    Sole purpose of using concurrency is to produce scalable and faster program. But always remember, sp ...

  3. Win8运行金山词霸2005的问题

    一般是以下几种状况: 1.运行进入假死 2.取词模块报错 3.词库突然丢失 原因: 文件权限和注册表权限问题 解决方法: 进入"..\Kingsoft\PowerWord 2005\&quo ...

  4. telnet命令的使用

    telnet是啥? Telnet协议是TCP/IP协议族中的一员,是Internet远程登陆服务的标准协议和主要方式.它为用户提供了在本地计算机上完成远程主机工作的能力.在终端使用者的电脑上使用tel ...

  5. Dispose模式释放非托管资源

    实现方式用的是设计模式里的模板模式,基类先搭好框架,子类重写void Dispose(bool disposing) 即可. 需要注意的是基类的Finalize函数也就是析构函数调用的是虚函数void ...

  6. 基于Linux整形时间的常用计算思路

    上一次分享了Linux时间时区详解与常用时间函数,相信大家对Linux常见时间函数的使用也有了一定的了解,在工作中遇到类似获取时间等需求的时候也一定能很好的处理.本文基于Linux整形时间给出一些简化 ...

  7. web安全之SQL注入---第四章 如何进行SQL注入攻击

    第四章 如何进行SQL注入攻击1.数字注入2.字符串注入    '#    '--

  8. c#中关于compare比较的一点注意事项

    一直没有太注意,今天发现在compare比较两个字符串的时候出了点小问题 如果我设置了两个字符串 一个是“2”,一个是“12” 那么在比较的时候 第一个会大于第二个: 如果第一个是“02”,第二个是“ ...

  9. polynomial time

    https://en.wikipedia.org/wiki/Time_complexity#Polynomial_time An algorithm is said to be of polynomi ...

  10. Java语言实现简单FTP软件------>连接管理模块的实现:主机与服务器之间的连接与关闭操作(八)

    (1)FTP连接 运行FTP客户端后,首先是连接FTP服务器,需要输入FTP服务器的IP地址及用户名.密码以及端口号后点击连接按钮开始连接FTP服务器,连接流程图如下图所示. 点击"连接&q ...