设计模式学习（十六）中介者模式 Mediator

最新推荐文章于 2024-04-23 15:21:35 发布

方寸间沧海桑田

最新推荐文章于 2024-04-23 15:21:35 发布

阅读量195

点赞数

分类专栏：设计模式学习设计模式学习（C++）文章标签：设计模式中介者模式 C++

本文链接：https://blog.csdn.net/yzt629/article/details/89500934

版权

设计模式学习同时被 2 个专栏收录

25 篇文章 0 订阅

订阅专栏

设计模式学习（C++）

23 篇文章 3 订阅

订阅专栏

1.中介者模式的定义

写在前面：中介者模式让我理解了很久，因为这个模式很贴近于我们的生活，因为所谓的这种“中介者”在我们的日常生活中遍地开花，但也正是如此，我在想把这种模式生活中的某种实例结合在一起时，我才发现其中的细节真的是需要多加揣摩才行。

中介者模式，其传统定义为用一个中介对象来封装一系列的对象交互，中介者使各对象不需要显示的相互引用，从而降低耦合，而且可以独立地改变它们之间的交互。
但通俗的说，这个模式也就是我们平常所见的各种中介所（买房，找工作之类的），这里以找工作为例。客户提供自己的基本信息，以及自己的目标相关职位，工作薪酬等信息；公司则提供自己的所需的职位信息以及所需技能等信息，中介所则负责将客户的信息统筹起来为一个库，将公司的招聘信息统筹为一个库，这样每当新的公司/客户进入库中时，都可以通过中介者的内部来匹配彼此需要的岗位/人才。也就是说，中介者模式就是一个，将客户/公司的需求收集起来组成两个库，然后在这两个有限的库中寻求最佳匹配的模式。
最后值得一提的是，中介者模式所需要配对的，常常是多个类的对象之间的配对过程，之所以选用中介者模式的原因，也正是由于其可以将不同类之间错综复杂的多对多关系，转换为一对一的关系—不同类之间，均只需要联系中介者类即可。同时，由于类之间的复杂联系均交给了中介者去处理，那么中介者类的结构将会相当复杂，变得不太易于更改。

2.中介者模式的类图

中介者模式的类图
关于这个类图，其中很值得一提的是ConcreteMediator具体中介者与ConcreteCollegue具体用户之间的单向关联关系，这代表着具体中介者是知晓每个具体的用户的，并将其作为其内部的成语变量来使用。之前学习的设计模式多为面向抽象类进行编程，所使用的成员变量多为抽象类中的成员变量，但此处却一反常态的是两个抽象类的具体类之间存在关联关系。
对于其中的每个类详细理解如下：

Mediator中介者类：这是一个抽象类，用来定义Collegue用户类到中介者对象所需要的所有接口。其可能有多种存在，对应的每种实现的接口也不尽相同；
Collegue用户类：这是一个抽象类，其中包含了所需要使用到的所有Mediator中介者类作为成员变量，并定义了具体的用户类需要实现的接口（多为用户信息的读取，以及对于Mediator中介者类的使用方式）；
ConcreteCollegue具体用户类：这是Collegue用户类的实例类，其可能有多种不同存在，表示不同类型的用户，不同的用户之间基本信息相同（继承自父类），但可能有不同的独特信息，并对Mediator中介者的使用方式可能也各有区别；
（每个ConcreteCollegue具体用户类都只知道自己的行为，并只认识中介者类，不知道其他ConcreteCollegue具体用户类的存在）
ConcreteMediator具体中介者类：这是Mediator中介者类的实例类，其可能有多种不同存在，对应实现不同的中介者功能。其内部有所有的ConcreteCollegue具体用户类的成员变量（即其需要了解所有的ConcreteCollegue具体用户类对象），其内部的功能函数（继承自父类的功能函数接口），都是需要依靠这些ConcreteCollegue具体用户类来进行操作的。
（当ConcreteCollegue具体用户类调用ConcreteMediator具体中介者类的功能函数接口时，可能需要传递一些信息才能实现对应的功能，比如其名字或其他在当前环境下有用的信息等）

3.中介者模式的代码实现

写在前面，这次的代码实现是我写的设计模式实现中最复杂的一次，实现过程写的也很烂。但是我还是感觉写完后没有将中介者模式的真正内涵表达出来，甚至我的这种案例其实不太需要中介者模式这种方式来实现，所以还需要更多需要改进的点，倘若日后有同学看到了这段渣码，欢迎指出优化方案

3.1 案例介绍

关于中介者模式的代码实现，我自己建立了这样的一个案例：

Student学生类：这是一个学校，学校中的每个学生都有自己的名字name，强项skill，弱项shortcoming，以及加入了的配对班组m_mediator，其类型为map<string,Mediator*>，由此，还有选择配对班的函数SetMediator和上配对班课的函数UseMediator；
具体Student学生类：目前学校里有三种学生，普通学生NormalStudent，体育生SportStudent和艺术生ArtStudent，这三种学生均继承自父类Student；
Mediator配对班类：配对班类是学校为不同类型的学生准备的学习交流班（即不能和同类型的学生配对），其中配对班Mediator有三种功能，实现普通学生NormalStudent与体育生SportStudent的配对NormalWithSport(string)，普通学生NormalStudent与艺术生ArtStudent的配对NormalWithArt(string)以及体育生SportStudent与艺术生ArtStudent的配对ArtWithSport(string)，这是三个虚函数，即学校需要配对班需要做到的功能，而实现这些功能，则通过具体的配对班来对应实现。
具体Mediator配对班：学校里分为三种配对班，通过强项与弱项配对的配对班Skill2Shortcoming_Mediator（俗称相辅相成），通过强项与强项配对的配对班Skill2Skill_Mediator（俗称强强联手），通过弱项与弱项配对的配对班Shortcoming2Shortcoming_Mediator（俗称抱团取暖）。三种类型的学生都可以随意加入这三种配对班，由此，每个配对班的内部也就有存储三种不同类型学生的变量如下：
m_normalstudent，m_sportstudent和m_artstudent，三种均为map结构。
所以与之配对的，三种配对班中还有向这些配对班的map库中增加变量的函数AddNormalStudent，AddSportStudent和AddArtStudent，

3.2 实施过程介绍

所以，对于本案例的实施过程如下：

建立所有的学生档案，不同类型的学生均创建数位（如normal_mike）；
建立三种不同的配对班，分别均设为1班（如skill2shortcoming_1）；
根据全校学生的信息，将所有的学生添加进入三个配对班的库中；（使用AddNormalStudent等函数）
向学生分发三个班的信息，学生自己选择想去哪些班上课，将该班加入自己的课表中；（使用SetMediator函数）
学生（如normal_mike）自己确定要去哪个班上课，然后在班中选择什么样的配对方式（使用UseMediator函数）。

3.3 对于这个案例的一点吐槽

综上所述，本例的代码实现过程如下：（其实本利的逻辑中有个小bug，应该是根据Student选择了什么配对班，然后再根据配对班内所选择的数据来进行配对操作的，这里是直接强制性的将全校同学全部入班，使得每个同学有主动选择配对的权利，而无法避免自己被别人配对的情况发生）
（解决这个问题的方法我想了一下，最好是在SetMediator时，将Student的信息存入对应的配对班Mediator的map结构中，而不是在开始就强制性地向其中添加所有学生的信息）
从本例中可以看出，中介者类的构造相当复杂，代码冗余量较大，当需要修改中介者类进行功能修订时，会比较麻烦。

#include <iostream>
#include <string>
#include <map>
using namespace std;

class Mediator
{
public:
	virtual void NormalWithSport(string) = 0;
	virtual void NormalWithArt(string) = 0;
	virtual void ArtWithSport(string) = 0;
};

class Student
{
public:
	Student(string name, string skill,string shortcoming) 
		: m_name(name), m_skill(skill),m_shortcoming(shortcoming) 
	{
		m_mediator = new map<string, Mediator*>;
	}
	void SetMediator(string name, Mediator* mediator) { m_mediator->insert({ name,mediator }); }
	string getName() { return m_name; }
	string getSkill() { return m_skill; }
	string getShortcoming() { return m_shortcoming; }
	virtual void UseMediator(string, int) = 0;
protected:
	string m_name;
	string m_skill;
	string m_shortcoming;
	map<string, Mediator*>* m_mediator;
};

class NormalStudent : public Student
{
public:
	NormalStudent(string name, string skill, string shortcoming) : Student(name, skill, shortcoming) {}
	void UseMediator(string mediatorname,int num)
	{
		if (num == 1)
			m_mediator->at(mediatorname)->NormalWithSport(m_name);
		if (num == 2)
			m_mediator->at(mediatorname)->NormalWithArt(m_name);
		if (num == 3)
		{
			m_mediator->at(mediatorname)->NormalWithSport(m_name);
			m_mediator->at(mediatorname)->NormalWithArt(m_name);
		}
	}
};

class SportStudent : public Student
{
public:
	SportStudent(string name, string skill, string shortcoming) : Student(name, skill, shortcoming) {}
	void UseMediator(string mediatorname, int num)
	{
		if (num == 1)
			m_mediator->at(mediatorname)->NormalWithSport(m_name);
		if (num == 2)
			m_mediator->at(mediatorname)->ArtWithSport(m_name);
		if (num == 3)
		{
			m_mediator->at(mediatorname)->NormalWithSport(m_name);
			m_mediator->at(mediatorname)->ArtWithSport(m_name);
		}
	}
};

class ArtStudent : public Student
{
public:
	ArtStudent(string name, string skill, string shortcoming) : Student(name, skill, shortcoming) {}
	void UseMediator(string mediatorname, int num)
	{
		if (num == 1)
			m_mediator->at(mediatorname)->NormalWithArt(m_name);
		if (num == 2)
			m_mediator->at(mediatorname)->ArtWithSport(m_name);
		if (num == 3)
		{
			m_mediator->at(mediatorname)->NormalWithArt(m_name);
			m_mediator->at(mediatorname)->ArtWithSport(m_name);
		}
	}
};

class Skill2Shortcoming_Mediator : public Mediator
{
public:
	Skill2Shortcoming_Mediator()
	{
		m_normalstudent = new map<string, NormalStudent*>;
		m_sportstudent = new map<string, SportStudent*>;
		m_artstudent = new map<string, ArtStudent*>;
	}
	void AddNormalStudent(NormalStudent* normalstudent)
	{
		m_normalstudent->insert({ normalstudent->getName(), normalstudent });
	}
	void AddSportStudent(SportStudent* sportstudent)
	{
		m_sportstudent->insert({ sportstudent->getName(),sportstudent });
	}
	void AddArtStudent(ArtStudent* artstudent)
	{
		m_artstudent->insert({ artstudent->getName(),artstudent });
	}
	void NormalWithSport(string name)
	{
		if (m_normalstudent->at(name) != NULL)
		{
			auto s1 = m_normalstudent->at(name);
			for (auto &s2 : *m_sportstudent)
			{
				if (s1->getSkill() == s2.second->getShortcoming())
					cout << "NormalStudent " << s1->getName() << " can be mate with SportStudent " << s2.second->getName() << " by Skill " << s2.second->getShortcoming() << endl;
				if (s1->getShortcoming() == s2.second->getSkill())
					cout << "NormalStudent " << s1->getName() << " can be mate with SportStudent " << s2.second->getName() << " by Shortcoming " << s2.second->getSkill() << endl;
			}
		}
		else if (m_sportstudent->at(name) != NULL)
		{
			auto s1 = m_sportstudent->at(name);
			for (auto &s2 : *m_normalstudent)
			{
				if (s1->getSkill() == s2.second->getShortcoming())
					cout << "SportStudent " << s1->getName() << " can be mate with SportStudent " << s2.second->getName() << " by Skill " << s2.second->getShortcoming() << endl;
				if (s1->getShortcoming() == s2.second->getSkill())
					cout << "SportStudent " << s1->getName() << " can be mate with SportStudent " << s2.second->getName() << " by Shortcoming " << s2.second->getSkill() << endl;
			}
		}
		else
		{
			cout << "the student don't belong to NormalStudent or SportStudent" << endl;
		}
	}
	void NormalWithArt(string name)
	{
		if (m_normalstudent->at(name) != NULL)
		{
			auto s1 = m_normalstudent->at(name);
			for (auto &s2 : *m_artstudent)
			{
				if (s1->getSkill() == s2.second->getShortcoming())
					cout << "NormalStudent " << s1->getName() << " can be mate with SportStudent " << s2.second->getName() << " by Skill " << s2.second->getShortcoming() << endl;
				if (s1->getShortcoming() == s2.second->getSkill())
					cout << "NormalStudent " << s1->getName() << " can be mate with SportStudent " << s2.second->getName() << " by Shortcoming " << s2.second->getSkill() << endl;
			}
		}
		else if ((*m_normalstudent)[name] != NULL)
		{
			auto s1 = (*m_normalstudent)[name];
			for (auto &s2 : *m_normalstudent)
			{
				if (s1->getSkill() == s2.second->getShortcoming())
					cout << "ArtStudent " << s1->getName() << " can be mate with ArtStudent " << s2.second->getName() << " by Skill " << s2.second->getShortcoming() << endl;
				if (s1->getShortcoming() == s2.second->getSkill())
					cout << "ArtStudent " << s1->getName() << " can be mate with ArtStudent " << s2.second->getName() << " by Shortcoming " << s2.second->getSkill() << endl;
			}
		}
		else
		{
			cout << "the student don't belong to NormalStudent or ArtStudent" << endl;
		}
	}
	void ArtWithSport(string name)
	{
		if ((*m_normalstudent)[name] != NULL)
		{
			auto s1 = (*m_normalstudent)[name];
			for (auto &s2 : *m_sportstudent)
			{
				if (s1->getSkill() == s2.second->getShortcoming())
					cout << "ArtStudent " << s1->getName() << " can be mate with SportStudent " << s2.second->getName() << " by Skill " << s2.second->getShortcoming() << endl;
				if (s1->getShortcoming() == s2.second->getSkill())
					cout << "ArtStudent " << s1->getName() << " can be mate with SportStudent " << s2.second->getName() << " by Shortcoming " << s2.second->getSkill() << endl;
			}
		}
		else if (m_sportstudent->at(name) != NULL)
		{
			auto s1 = m_sportstudent->at(name);
			for (auto &s2 : *m_artstudent)
			{
				if (s1->getSkill() == s2.second->getShortcoming())
					cout << "SportStudent " << s1->getName() << " can be mate with ArtStudent " << s2.second->getName() << " by Skill " << s2.second->getShortcoming() << endl;
				if (s1->getShortcoming() == s2.second->getSkill())
					cout << "SportStudent " << s1->getName() << " can be mate with ArtStudent " << s2.second->getName() << " by Shortcoming " << s2.second->getSkill() << endl;
			}
		}
		else
		{
			cout << "the student don't belong to SportStudent or ArtStudent" << endl;
		}
	}
private:
	map<string, NormalStudent*>* m_normalstudent;
	map<string, SportStudent*>* m_sportstudent;
	map<string, ArtStudent*>* m_artstudent;
};

class Skill2Skill_Mediator : public Mediator
{
public:
	Skill2Skill_Mediator()
	{
		m_normalstudent = new map<string, NormalStudent*>;
		m_sportstudent = new map<string, SportStudent*>;
		m_artstudent = new map<string, ArtStudent*>;
	}
	void AddNormalStudent(NormalStudent* normalstudent)
	{
		m_normalstudent->insert({ normalstudent->getName(),normalstudent });
	}
	void AddSportStudent(SportStudent* sportstudent)
	{
		m_sportstudent->insert({ sportstudent->getName(),sportstudent });
	}
	void AddArtStudent(ArtStudent* artstudent)
	{
		m_artstudent->insert({ artstudent->getName(),artstudent });
	}
	void NormalWithSport(string name)
	{
		if (m_normalstudent->find(name) != m_normalstudent->end())
		{
			auto s1 = m_normalstudent->at(name);
			for (auto &s2 : *m_sportstudent)
			{
				if (s1->getSkill() == s2.second->getSkill())
					cout << "NormalStudent " << s1->getName() << " can be mate with SportStudent " << s2.second->getName() << " by Skill " << s2.second->getSkill() << endl;
			}
		}
		else if (m_sportstudent->find(name) != m_sportstudent->end())
		{
			auto s1 = m_sportstudent->at(name);
			for (auto &s2 : *m_normalstudent)
			{
				if (s1->getSkill() == s2.second->getSkill())
					cout << "SportStudent " << s1->getName() << " can be mate with NormalStudent " << s2.second->getName() << " by Skill " << s2.second->getSkill() << endl;
			}
		}
		else
		{
			cout << "the student don't belong to SportStudent or NormalStudent" << endl;
		}
	}
	void NormalWithArt(string name)
	{
		if (m_normalstudent->find(name) != m_normalstudent->end())
		{
			auto s1 = m_normalstudent->at(name);
			for (auto &s2 : *m_artstudent)
			{
				if (s1->getSkill() == s2.second->getSkill())
					cout << "NormalStudent " << s1->getName() << " can be mate with ArtStudent " << s2.second->getName() << " by Skill " << s2.second->getSkill() << endl;
			}
		}
		else if (m_artstudent->find(name) != m_artstudent->end())
		{
			auto s1 = m_artstudent->at(name);
			for (auto &s2 : *m_normalstudent)
			{
				if (s1->getSkill() == s2.second->getSkill())
					cout << "ArtStudent " << s1->getName() << " can be mate with NormalStudent " << s2.second->getName() << " by Skill " << s2.second->getSkill() << endl;
			}
		}
		else
		{
			cout << "the student don't belong to ArtStudent or NormalStudent" << endl;
		}
	}
	void ArtWithSport(string name)
	{
		if (m_artstudent->find(name) != m_artstudent->end())
		{
			auto s1 = (*m_artstudent)[name];
			for (auto &s2 : *m_sportstudent)
			{
				if (s1->getSkill() == s2.second->getSkill())
					cout << "ArtStudent " << s1->getName() << " can be mate with SportStudent " << s2.second->getName() << " by Skill " << s2.second->getSkill() << endl;
			}
		}
		else if (m_sportstudent->find(name) != m_sportstudent->end())
		{
			auto s1 = m_sportstudent->at(name);
			for (auto &s2 : *m_artstudent)
			{
				if (s1->getSkill() == s2.second->getSkill())
					cout << "SportStudent " << s1->getName() << " can be mate with NormalStudent " << s2.second->getName() << " by Skill " << s2.second->getSkill() << endl;
			}
		}
		else
		{
			cout << "the student don't belong to ArtStudent or SportStudent" << endl;
		}
	}
private:
	map<string, NormalStudent*>* m_normalstudent;
	map<string, SportStudent*>* m_sportstudent;
	map<string, ArtStudent*>* m_artstudent;
};

class Shortcoming2Shortcoming_Mediator : public Mediator
{
public:
	Shortcoming2Shortcoming_Mediator()
	{
		m_normalstudent = new map<string, NormalStudent*>;
		m_sportstudent = new map<string, SportStudent*>;
		m_artstudent = new map<string, ArtStudent*>;
	}
	void AddNormalStudent(NormalStudent* normalstudent)
	{
		m_normalstudent->insert({ normalstudent->getName(),normalstudent });
	}
	void AddSportStudent(SportStudent* sportstudent)
	{
		m_sportstudent->insert({ sportstudent->getName(),sportstudent });
	}
	void AddArtStudent(ArtStudent* artstudent)
	{
		m_artstudent->insert({ artstudent->getName(),artstudent });
	}
	void NormalWithSport(string name)
	{
		if (m_normalstudent->find(name) != m_normalstudent->end())
		{
			auto s1 = m_normalstudent->at(name);
			for (auto &s2 : *m_sportstudent)
			{
				if (s1->getShortcoming() == s2.second->getShortcoming())
					cout << "NormalStudent " << s1->getName() << " can be mate with SportStudent " << s2.second->getName() << " by Shortcoming " << s2.second->getShortcoming() << endl;
			}
		}
		else if (m_sportstudent->find(name) != m_sportstudent->end())
		{
			auto s1 = m_sportstudent->at(name);
			for (auto &s2 : *m_normalstudent)
			{
				if (s1->getShortcoming() == s2.second->getShortcoming())
					cout << "SportStudent " << s1->getName() << " can be mate with NormalStudent " << s2.second->getName() << " by Shortcoming " << s2.second->getShortcoming() << endl;
			}
		}
		else
		{
			cout << "the student don't belong to SportStudent or NormalStudent" << endl;
		}
	}
	void NormalWithArt(string name)
	{
		if (m_normalstudent->find(name) != m_normalstudent->end())
		{
			auto s1 = m_normalstudent->at(name);
			for (auto &s2 : *m_artstudent)
			{
				if (s1->getShortcoming() == s2.second->getShortcoming())
					cout << "NormalStudent " << s1->getName() << " can be mate with ArtStudent " << s2.second->getName() << " by Shortcoming " << s2.second->getShortcoming() << endl;
			}
		}
		else if (m_artstudent->find(name) != m_artstudent->end())
		{
			auto s1 = (*m_artstudent)[name];
			for (auto &s2 : *m_normalstudent)
			{
				if (s1->getShortcoming() == s2.second->getShortcoming())
					cout << "ArtStudent " << s1->getName() << " can be mate with NormalStudent " << s2.second->getName() << " by Shortcoming " << s2.second->getShortcoming() << endl;
			}
		}
		else
		{
			cout << "the student don't belong to ArtStudent or NormalStudent" << endl;
		}
	}
	void ArtWithSport(string name)
	{
		if (m_artstudent->find(name) != m_artstudent->end())
		{
			auto s1 = (*m_artstudent)[name];
			for (auto &s2 : *m_sportstudent)
			{
				if (s1->getShortcoming() == s2.second->getShortcoming())
					cout << "ArtStudent " << s1->getName() << " can be mate with SportStudent " << s2.second->getName() << " by Shortcoming " << s2.second->getShortcoming() << endl;
			}
		}
		else if (m_sportstudent->find(name) != m_sportstudent->end())
		{
			auto s1 = m_sportstudent->at(name);
			for (auto &s2 : *m_artstudent)
			{
				if (s1->getShortcoming() == s2.second->getShortcoming())
					cout << "SportStudent " << s1->getName() << " can be mate with NormalStudent " << s2.second->getName() << " by Shortcoming " << s2.second->getShortcoming() << endl;
			}
		}
		else
		{
			cout << "the student don't belong to ArtStudent or SportStudent" << endl;
		}
	}
private:
	map<string, NormalStudent*>* m_normalstudent;
	map<string, SportStudent*>* m_sportstudent;
	map<string, ArtStudent*>* m_artstudent;
};


int main()
{
	//1.学生的定义过程
	NormalStudent* normal_mike = new NormalStudent("mike", "math", "soccer");
	NormalStudent* normal_jack = new NormalStudent("jack", "english", "basketball");
	NormalStudent* normal_wide = new NormalStudent("wide", "run", "physical");

	SportStudent* sport_liuxiang = new SportStudent("liuxiang", "run", "math");
	SportStudent* sport_yaoming = new SportStudent("yaoming", "basketball", "english");
	SportStudent* sport_zhengzhi = new SportStudent("zhengzhi", "soccer", "paint");
	SportStudent* sport_sunyang = new SportStudent("sunyang", "swim", "sing");

	ArtStudent* art_linda = new ArtStudent("linda", "paint", "english");
	ArtStudent* art_lily = new ArtStudent("lily", "sing", "swim");
	ArtStudent* art_sam = new ArtStudent("sam", "dance", "physical");

	//2.配对班的定义过程
	Skill2Shortcoming_Mediator* skill2shortcoming_1 = new Skill2Shortcoming_Mediator;
	Skill2Skill_Mediator* skill2skill_1 = new Skill2Skill_Mediator;
	Shortcoming2Shortcoming_Mediator* shortcoming2shortcoming_1 = new Shortcoming2Shortcoming_Mediator;

	//3.配对班的信息添加过程（每个配对班根据学生档案得到所有学生信息）
	skill2shortcoming_1->AddNormalStudent(normal_mike);
	skill2shortcoming_1->AddNormalStudent(normal_jack);
	skill2shortcoming_1->AddNormalStudent(normal_wide);
	skill2shortcoming_1->AddSportStudent(sport_liuxiang);
	skill2shortcoming_1->AddSportStudent(sport_yaoming);
	skill2shortcoming_1->AddSportStudent(sport_zhengzhi);
	skill2shortcoming_1->AddSportStudent(sport_sunyang);
	skill2shortcoming_1->AddArtStudent(art_linda);
	skill2shortcoming_1->AddArtStudent(art_lily);
	skill2shortcoming_1->AddArtStudent(art_sam);

	skill2skill_1->AddNormalStudent(normal_mike);
	skill2skill_1->AddNormalStudent(normal_jack);
	skill2skill_1->AddNormalStudent(normal_wide);
	skill2skill_1->AddSportStudent(sport_liuxiang);
	skill2skill_1->AddSportStudent(sport_yaoming);
	skill2skill_1->AddSportStudent(sport_zhengzhi);
	skill2skill_1->AddSportStudent(sport_sunyang);
	skill2skill_1->AddArtStudent(art_linda);
	skill2skill_1->AddArtStudent(art_lily);
	skill2skill_1->AddArtStudent(art_sam);

	shortcoming2shortcoming_1->AddNormalStudent(normal_mike);
	shortcoming2shortcoming_1->AddNormalStudent(normal_jack);
	shortcoming2shortcoming_1->AddNormalStudent(normal_wide);
	shortcoming2shortcoming_1->AddSportStudent(sport_liuxiang);
	shortcoming2shortcoming_1->AddSportStudent(sport_yaoming);
	shortcoming2shortcoming_1->AddSportStudent(sport_zhengzhi);
	shortcoming2shortcoming_1->AddSportStudent(sport_sunyang);
	shortcoming2shortcoming_1->AddArtStudent(art_linda);
	shortcoming2shortcoming_1->AddArtStudent(art_lily);
	shortcoming2shortcoming_1->AddArtStudent(art_sam);

	//4.学生自己选择加入配对班的过程（此处只选用几位同学）
	normal_mike->SetMediator("skill2shortcoming_1", skill2shortcoming_1);
	normal_mike->SetMediator("skill2skill_1", skill2skill_1);
	normal_mike->SetMediator("shortcoming2shortcoming_1", shortcoming2shortcoming_1);

	sport_liuxiang->SetMediator("skill2shortcoming_1", skill2shortcoming_1);
	sport_liuxiang->SetMediator("skill2skill_1", skill2skill_1);
	sport_liuxiang->SetMediator("shortcoming2shortcoming_1", shortcoming2shortcoming_1);

	art_linda->SetMediator("skill2shortcoming_1", skill2shortcoming_1);
	art_linda->SetMediator("skill2skill_1", skill2skill_1);
	art_linda->SetMediator("shortcoming2shortcoming_1", shortcoming2shortcoming_1);

	//5.学生在自己加入的配对班中选择配对方式，完成上课（中介不同功能不同，但是配对的都是非自己类型的学生）
	//中介者的功能数字123，1和2指和另外两种不同的类型学生配对，3是对所有学生配对
	cout << normal_mike->getName() << "'s match process!" << endl;
	normal_mike->UseMediator("skill2shortcoming_1", 1);
	normal_mike->UseMediator("skill2shortcoming_1", 2);
	normal_mike->UseMediator("skill2shortcoming_1", 3);
	cout << sport_liuxiang->getName() << "'s match process!" << endl;
	sport_liuxiang->UseMediator("skill2skill_1", 1);
	sport_liuxiang->UseMediator("skill2skill_1", 2);
	sport_liuxiang->UseMediator("skill2skill_1", 3);
	cout << art_linda->getName() << "'s match process!" << endl;
	art_linda->UseMediator("shortcoming2shortcoming_1", 1);
	art_linda->UseMediator("shortcoming2shortcoming_1", 2);
	art_linda->UseMediator("shortcoming2shortcoming_1", 3);

	return 0;
}

方寸间沧海桑田

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
设计模式学习（十六）中介者模式 Mediator

1.中介者模式的定义写在前面：中介者模式让我理解了很久，因为这个模式很贴近于我们的生活，因为所谓的这种“中介者”在我们的日常生活中遍地开花，但也正是如此，我在想把这种模式生活中的某种实例结合在一起时，我才发现其中的细节真的是需要多加揣摩才行。中介者模式，其传统定义为用一个中介对象来封装一系列的对象交互，中介者使各对象不需要显示的相互引用，从而降低耦合，而且可以独立地改变它们之间的交互。...
复制链接

扫一扫