这两天啊,我是又当代理又当中介的,给我累得,都没怎么学习。
代理啥呀?用我的一技之长,处理客户的需求嘛。但是吧,我从小受到的教育告诉我,要解放自己的时间,即时你不知道那些时间该干嘛,先解放出来再说。于是我就去干中介了。
这中介是怎么干呢?挖掘一堆的客户,收集客户需求;聚拢一群代理,向他们发放客户需求。这是初级的。
当撮合了一对一对之后呢?
当然就要充当他们一对一的中间人了,既不能让他们之间互相起交集(说多了都是泪,两年前我让他们起交集,然后,我就成多余的了),又不能让他们之间的消息通不了。又得盯着发单方跑路不结账,又得看着接单者每天完成任务。
难喏。
这个事件中有哪些主要信息呢?
发单者、接单者、中介者。
有哪些交流呢?
发单者通过中介找到接单者,接单者通过中介接单,双方通过中介通信。
哪天要是这个中介撂挑子不干了,比如我,这会儿我就不干了,写博客,那么整个系统将陷入瘫痪。
好,画个图。
这个有点难搞啊,是真的难搞。
#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++跟你聊聊“中介者模式”,也是我的,看完你就知道什么叫触目惊心了。
中介者负荷过高。
用于一堆乱麻式的交互场景。中介者模式简单,但是也容易误用,不要为了使用中介者模式而使用它。
今天有点累,那个“原型模式”我就不写了,可以看我之前那篇就好。
下一篇:命令模式