学以致用C++设计模式之“中介模式”看，未来的博客-

陀螺般的中介

这两天啊，我是又当代理又当中介的，给我累得，都没怎么学习。
代理啥呀？用我的一技之长，处理客户的需求嘛。但是吧，我从小受到的教育告诉我，要解放自己的时间，即时你不知道那些时间该干嘛，先解放出来再说。于是我就去干中介了。
这中介是怎么干呢？挖掘一堆的客户，收集客户需求；聚拢一群代理，向他们发放客户需求。这是初级的。
当撮合了一对一对之后呢？
当然就要充当他们一对一的中间人了，既不能让他们之间互相起交集（说多了都是泪，两年前我让他们起交集，然后，我就成多余的了），又不能让他们之间的消息通不了。又得盯着发单方跑路不结账，又得看着接单者每天完成任务。
难喏。

这个事件中有哪些主要信息呢？
发单者、接单者、中介者。
有哪些交流呢？
发单者通过中介找到接单者，接单者通过中介接单，双方通过中介通信。
哪天要是这个中介撂挑子不干了，比如我，这会儿我就不干了，写博客，那么整个系统将陷入瘫痪。

好，画个图。

这是一段防爬虫文字，读者可跳过
本文为ImapBox作者“看，未来”原创，我的ImapBox地址为 https://lion-wu.blog.csdn.net/
本篇隶属于我的专栏 – 《设计模式 之 设计模式进阶》https://blog.csdn.net/qq_43762191/category_10059121.html
作者版权，未经允许，禁止转载。

代码实现

这个有点难搞啊，是真的难搞。

#include<iostream> #include<string> #include<vector> using namespace std; class abstractF; //收单者抽象类 class abstractS { public: virtual void FXX(string f) = 0; virtual void SXX(string s) = 0; virtual void set_F(abstractF* F) = 0; virtual void notify() = 0; }; //抽象发单者 class abstractF { public: virtual void FXX(string f) = 0; virtual void SXX(string s) = 0; virtual void set_S(abstractS* S) = 0; virtual void notify() = 0; }; //具体发单者 class FA :public abstractF { private:  abstractS* S; //临时变量  vector<string> f; public: //发消息 void FXX(string f) { this->f.push_back(f); } void SXX(string s) {   cout << "FA收到消息：" << s << endl; } void set_S(abstractS* S) { this->S = S; } void notify() {   vector<string>::iterator its; for (its = f.begin(); its != f.end(); its++){    S->SXX(*its); }   f.clear(); } }; class FB :public abstractF { private:  abstractS* S; //临时变量  vector<string> f; public: //发消息 void FXX(string f) { this->f.push_back(f); } void SXX(string s) {   cout << "FB收到消息：" << s << endl; } void set_S(abstractS* S) { this->S = S; } void notify() {   vector<string>::iterator its; for (its = f.begin(); its != f.end(); its++){    S->SXX(*its); }   f.clear(); } }; //具体收单者 class SA :public abstractS { private:  abstractF* F; //临时变量  vector<string> f; public: //发消息 void FXX(string f) { this->f.push_back(f); } void SXX(string s) {   cout << "SA收到消息：" << s << endl; } void set_F(abstractF* F) { this->F = F; } void notify() {   vector<string>::iterator itf; for (itf = f.begin(); itf != f.end(); itf++){    F->SXX(*itf); }   f.clear(); } }; class SB :public abstractS { private:  abstractF* F; //临时变量  vector<string> f; public: //发消息 void FXX(string f) { this->f.push_back(f); } void SXX(string s) {   cout << "SB收到消息：" << s << endl; } void set_F(abstractF* F) { this->F = F; } void notify() {   vector<string>::iterator itf; for (itf = f.begin(); itf != f.end(); itf++){    F->SXX(*itf); }   f.clear(); } }; //中介 class ZJ { private:  vector<abstractF*> f;  vector<abstractS*> s; public: void add_F(abstractF* F) { f.push_back(F); } void add_S(abstractS* S) { s.push_back(S); } void notifyF() {   vector<abstractF*>::iterator nf; for (nf = f.begin(); nf != f.end(); nf++) { (*nf)->notify(); } } void notifyS() {   vector<abstractS*>::iterator ns; for (ns = s.begin(); ns != s.end(); ns++) { (*ns)->notify(); } } }; int main() {  abstractF* fa = new FA();  abstractF* fb = new FB();  abstractS* sa = new SA();  abstractS* sb = new SB();  ZJ* zj = new ZJ(); //while (1) //{ //Sleep(1000);    fa->set_S(sa);  fb->set_S(sb);  sa->set_F(fa);  sb->set_F(fb);   zj->add_F(fa);  zj->add_F(fb);  zj->add_S(sa);  zj->add_S(sb);    fa->FXX("enen");  fa->FXX("oo");  fb->FXX("haha");  fb->FXX("heihei");   sa->FXX("enen");  sa->FXX("oo");  sb->FXX("haha");  sb->FXX("heihei");   zj->notifyF();  zj->notifyS(); //} } 

写时感悟

这个要求细节很细啊，而且那个notify放在具体实现类，不止是一个中介者要notify。
反正就是细节要求特别高，然后中介者不能崩了，场景也不能塌了。

中介者模式

又称“调停者模式”。
用一个中介对象封装一系列对象交互，中介者使各对象不需要显示的相互作用，从而使其耦合松散，而且可以改变他们之间的交互。

应用场景

优点

减少了依赖，这里可能不是很触目惊心，看这篇：用C++跟你聊聊“中介者模式”，也是我的，看完你就知道什么叫触目惊心了。

缺点

中介者负荷过高。

应用场景

用于一堆乱麻式的交互场景。中介者模式简单，但是也容易误用，不要为了使用中介者模式而使用它。

今天有点累，那个“原型模式”我就不写了，可以看我之前那篇就好。
下一篇：命令模式