设计模式，中介者模式c++实现，避免多个类之间相互紧耦合

中介者模式：多对多关系变成多对一关系
当多个类因功能函数的关系相互耦合时，用一个中介对象封装一系列的对象交互，中介者使各对象不需要显式的相互作用，从而使其耦合松散，而且可以独立的改变它们之间的交互。

中间那个就是mediator中介者
定义统一的接口，用于各个同事之间的通信
周围的就是具体角色，这个例子中叫worker类
每个角色都知道中介者角色，而且与其他同事通信时，一定要通过中介者角色协作。
worker类的两种行为：
自发行为(self-Method)：改变自己的状态，处理自己的行为。
依赖方法(Dep-Method)：必须依赖中介者才能完成的行为。

实现方法：
中介者类中一般包含的是同事类细节子类，中介者解决的是同事类工作方法细节的不同产生的依赖，所以前提就是同事类细节中的方法不一样，如果包含的是同事类抽象类（基类），那中介者类就会因为无法调用具体子类的额外细节方法而失去作用。

中介者一般只有一个：包含其所管理维护的所有同事细节，但这些细节不需要被构造而可以通过参数传递进来（Java中可能叫“注入”）

中介者使用get/set获取同事类 //中介者不需要有全部同事类
同事类用构造函数获取中介者 //同事类必须拥有中介者

中介者模式的优点：
减少类间依赖，降低耦合

缺点：
中介者需包含所有业务，自身代码膨胀，逻辑复杂，并会随着同事类和业务的增加变得更膨胀，更复杂。

场景：
将多个对象相互紧密耦合而产生蜘蛛网状结构（10台电脑两两相连实现通信），变成星形结构（10台电脑连在一台交换机上实习了相互通信）
比如：某某机场调度中心，给飞机安排停机坪。

实际应用：MVC框架
利用C(Controller)中介者，名为前端控制器（Front Controller），将M(Model,业务逻辑)和V(view，视图)隔离开，协调M和V协同工作，把M运行的结果与V代表的视图融合成一个前端可以展示的画面，减少MV之间的依赖关系。

下面有个使用中介者模式的代码样例，使用cooker类通过中介者mediator调用assistance，carrier，cleaner的方法而没有使cooker类与这些类产生耦合。

c/c++实现中介者这种有相互依赖的情况时有个步骤，在之前的博客里面讲到过，一定要按以下流程写：
1.声明所有类，无顺序要求，存在继承关系的不需要写继承关系，只写类名就行。
2.声明所有类的函数与数据，否则将类作为参数时会报错。
3.类外实现所有函数，否则再函数体中调用其他类的函数时会报错。

enum responsebility
{
	cookRes,
	cleanRes,
	assistRes,
	carryRes,
};
//声明所有类，存在继承关系的不需要写继承关系，只写类名就行
class worker;
class cooker;
class carrier;
class cleaner;
class assistant;
class mediator;

//声明所有类的数据和函数
class mediator
{
public:
	void work(responsebility& Responsibility);

	void SetCooker(cooker* _cooker);

	void SetCleaner(cleaner* _cleaner);

	void SetCarrier(carrier* _carrier);

	void SetAssistant(assistant* _assiatant);

protected:
	void clean(responsebility& Responsibility);

	void carry(responsebility& Responsibility);

	void assist(responsebility& Responsibility);

	void cook(responsebility& Responsibility);

	cleaner* mCleaner;
	cooker* mCooker;
	assistant* mAssistant;
	carrier* mCarrier;
};

class worker
{
public:
	virtual void work(responsebility& Responsibility)
	{

	}
protected:
	mediator* mMediator;
	responsebility mResponsibility;
};

class cleaner:public worker
{
public:
	cleaner(mediator* _mediator);

	void clean(responsebility& Responsibility);
};

class cooker :public worker
{
public:
	cooker(mediator* _mediator);
	void cook(responsebility& Responsibility);
};

class assistant :public worker
{
public:
	assistant(mediator* _mediator);
	void assist(responsebility& Responsibility);
};

class carrier :public worker
{
public:
	carrier(mediator* _mediator);
	void carry(responsebility& Responsibility);
};

//实现所有类函数
void mediator::clean(responsebility& Responsibility)
{
	mCleaner->clean(Responsibility);
}

void mediator::carry(responsebility& Responsibility)
{
	mCarrier->carry(Responsibility);
}

void mediator::assist(responsebility& Responsibility)
{
	mAssistant->assist(Responsibility);
}

void mediator::cook(responsebility& Responsibility)
{
	mCooker->cook(Responsibility);
}

void mediator::work(responsebility& Responsibility)
{
	switch (Responsibility)
	{
	case cookRes:
		cook(Responsibility);
		break;
	case carryRes:
		carry(Responsibility);
		break;
	case cleanRes:
		clean(Responsibility);
		break;
	case assistRes:
		assist(Responsibility);
		break;
	default:
		break;
	}
}

void mediator::SetCooker(cooker* _cooker)
{
	mCooker = _cooker;
}

void mediator::SetCleaner(cleaner* _cleaner)
{
	mCleaner = _cleaner;
}

void mediator::SetCarrier(carrier* _carrier)
{
	mCarrier = _carrier;
}

void mediator::SetAssistant(assistant* _assiatant)
{
	mAssistant = _assiatant;
}

cleaner::cleaner(mediator* _mediator)
{
	mMediator = _mediator;
	mResponsibility = cleanRes;
}

void cleaner::clean(responsebility& Responsibility)
{
	if (mResponsibility == Responsibility)
	{
		cout << "扫地" << endl;
	}
	else
	{
		mMediator->work(Responsibility);
	}

}

/
cooker::cooker(mediator* _mediator)
{
	mMediator = _mediator;
	mResponsibility = cookRes;
}
void cooker::cook(responsebility& Responsibility)
{
	if (mResponsibility == Responsibility)
	{
		cout << "做饭" << endl;
	}
	else
	{
		mMediator->work(Responsibility);
	}

}

/
assistant::assistant(mediator* _mediator)
{
	mMediator = _mediator;
	mResponsibility = assistRes;
}
void assistant::assist(responsebility& Responsibility)
{
	if (mResponsibility == Responsibility)
	{
		cout << "招待客人" << endl;
	}
	else
	{
		mMediator->work(Responsibility);
	}

}

/
carrier::carrier(mediator* _mediator)
{
	mMediator = _mediator;
	mResponsibility = carryRes;
}
void carrier::carry(responsebility& Responsibility)
{
	if (mResponsibility == Responsibility)
	{
		cout << "搬东西" << endl;
	}
	else
	{
		mMediator->work(Responsibility);
	}
}

//测试函数
void func()
{
	mediator* Mediator = new mediator();

	cooker* Cooker = new cooker(Mediator);
	carrier* Carrier = new carrier(Mediator);
	cleaner* Cleaner = new cleaner(Mediator);
	assistant* Assistant = new assistant(Mediator);

	Mediator->SetAssistant(Assistant);
	Mediator->SetCarrier(Carrier);
	Mediator->SetCleaner(Cleaner);
	Mediator->SetCooker(Cooker);

	vector mission;
	mission.push_back(cookRes);
	mission.push_back(carryRes);
	mission.push_back(assistRes);
	mission.push_back(carryRes);
	mission.push_back(cleanRes);

	vector::iterator itMission = mission.begin();
	while (itMission != mission.end())
	{
		Cooker->cook(*itMission);
		++itMission;
	}
}

这里面cooker的工作函数只有cook(),当他通过中介者调用其他类的功能时，没有和被调用的类产生耦合，达到了通过中介者减少类间耦合的目的。