“设计模式”学习之七：解释器与中介者（行为型）

一、解释器（Interpreter）

1、引言

该模式一般用于为某种简单的特定类型的问题（如简单语言）提供一种文法，使用类来解释当中的每一条规则。

给出几种典型应用场合：正则表达式的解释与匹配、布尔表达式的操作、计算24的实例（http://www.cnblogs.com/mahope/archive/2005/05/04/149246.html）、XML格式数据解析、从大写汉字“一千零五万六千零七十二”到数字“10056072”的转换实例（http://www.cnblogs.com/MaoBisheng/archive/2008/09/08/1287014.html）等等。

可见，解释器模式应用于：较简单的文法（若复杂，则需要语法分析程序生成器）；各文法规则明确独立、易于扩展；效率不是最关键因素的情况。

 

2、一般思路

下图，上下文Context会包含解释器之外的全局信息。非终结符类NonterminalExpression会递归调用终结符类TerminalExpression。客户需自行构建抽象语法树——表示某表达式，并调用解释操作Interpreter()。

 

3、典型代码

基本程序代码参见《设计模式精解-GoF 23种设计模式解析附C++实现源码》即可，暂时空缺其它应用实例，待补…

 

4、应用提示

（1）Interpreter模式提供了一种很好的组织和设计简单语言文法解析器的架构。

（2）Interpreter模式的缺点在于，不适于构建复杂文法的解释器。

（3）抽象语法树是一个Composite模式的实例。

（4）终结符类TerminalExpression的实例可应用Flyweight模式在抽象语法树中共享。

（5）不一定要在结点类中定义解释操作Interpreter()，可应用Visitor模式将解释放入一个独立的“访问者”类，以避免在每个结点类都定义需要的几种独立的解释操作。

 

二、中介者（Mediator）

1、引言

面向对象设计鼓励将行为分布到各个对象中。中介者模式通过将各个对象间的交互封装到一个中介者对象中，从而将多对多的通信转变为一对多，降低系统复杂性，这符合OO设计中的职责单一集中的原则。

 

2、一般思路

下图，中介者Mediator/ConcreteMediator负责与同事类的对象进行通信，而具体同事ConcreteColleagueA/B无需彼此引用，只需知道中介者即可，其接口函数易于扩展。

定义抽象类Mediator是为了使各个ConcreteColleague能够与不同的中介者共同工作，当仅有唯一一个中介者时，无需定义Mediator。

 

3、典型代码

参考：http://www.cnblogs.com/ywqu/archive/2010/02/09/1666196.html，实现一个简易聊天功能，聊城室就是一个中介者，参与聊天的人就是同事对象。

// "Mediator_Chatroom.h":头文件//

#ifndef _MEDIATOR_CHATROOM_H_
#define _MEDIATOR_CHATROOM_H_

#include <vector>
#include <iostream>
#include <conio.h>
#include <string>
using namespace std;

class AbstractColleague;

class MediatorChatroom
{
private:
	vector <AbstractColleague *> vecColleague;

public:
	MediatorChatroom(){}
	~MediatorChatroom(){}

	void Register(AbstractColleague *talker);
	void Send(string from, string to, string message);
};

class AbstractColleague
{
public:
	AbstractColleague(MediatorChatroom * chatroom, string strColleagueValue)
	{
		this->_chatroom = chatroom;
		this->_strColleagueValue = strColleagueValue;
	}
	virtual ~AbstractColleague(){}

	virtual void Receive(string from,string message)
	{
		cout<<"<"<<from<<"> to <"<<_strColleagueValue<<">：  "<<message<<endl;
	}

public:
	MediatorChatroom *  _chatroom;
	string _strColleagueValue;

	void Send(string to, string message)
	{
		_chatroom->Send(_strColleagueValue, to, message);
	}
};

class ColleagueINer : public AbstractColleague
{
public:
	ColleagueINer(MediatorChatroom * chatroom, string strColleagueValue)
		:AbstractColleague(chatroom, strColleagueValue){}
	~ColleagueINer(){}

	void Receive(string from,string message)
	{
		cout<<"To one INer：";
		AbstractColleague::Receive(from, message);
	}
};

class ColleagueOUTer : public AbstractColleague
{
public:
	ColleagueOUTer(MediatorChatroom * chatroom, string strColleagueValue)
		:AbstractColleague(chatroom, strColleagueValue){}
	~ColleagueOUTer(){}

	void Receive(string from,string message)
	{
		cout<<"To one OUTer：";
		AbstractColleague::Receive(from, message);
	}
};

#endif //~_MEDIATOR_CHATROOM_H_


// Mediator_Chatroom.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include "Mediator_Chatroom.h"

void MediatorChatroom::Register(AbstractColleague *talker)
{
	//引入迭代器实现按顺序访问池中的各参与者对象
	vector <AbstractColleague *>:: iterator it = vecColleague.begin();
	//	AbstractColleague * talkerTemp;
	if (vecColleague.size() == 0)//当容器内无任何对象时，先push一个对象
	{
		//		flyTemp = new ConcreteFlyweight(key);
		vecColleague.push_back(talker);
		return;
	}
	for (; it != vecColleague.end(); it++)//遍历对象
	{
		string tem = talker->_strColleagueValue;
		if ((*it)->_strColleagueValue == talker->_strColleagueValue)//若存在，则返回。
		{
			cout<<"Check <"<<talker->_strColleagueValue<<">：Ensure it used only once..."<<endl;
			return;
		}
		//	flyTemp = new ConcreteFlyweight(key);
		vecColleague.push_back(talker);
		return;
		//	return flyTemp;
	}
}//

void MediatorChatroom::Send(string from, string to, string message)
{
	vector <AbstractColleague *>:: iterator it = vecColleague.begin();
	for (; it != vecColleague.end(); it++)//遍历对象
	{
		if ((*it)->_strColleagueValue == to)//若接收存在，则让其接收信息。
		{
			(*it)-> Receive(from, message);
			return;
			//	cout<<"Check <"<<talker->_strColleagueValue<<">：Ensure it used only once..."<<endl;
		}
		else
		{
//			cout<<"<"<<to<<">：doesn't existed!"<<endl;
//			return;
		}
		//	flyTemp = new ConcreteFlyweight(key);
		//	vecColleague.push_back(talker);
		//	return flyTemp;
	}
}

int _tmain(int argc, _TCHAR* argv[])
{
	MediatorChatroom *chatroom = new MediatorChatroom;

	AbstractColleague *LiLei = new ColleagueINer(chatroom, "LiLei");
	AbstractColleague *HanMeimei = new ColleagueINer(chatroom, "HanMeimei");
	AbstractColleague *Poly = new ColleagueINer(chatroom, "Poly");

	AbstractColleague *SongJiang = new ColleagueOUTer(chatroom, "SongJiang");

	chatroom->Register(LiLei);
	chatroom->Register(HanMeimei);
	chatroom->Register(Poly);

	chatroom->Register(SongJiang);

	LiLei->Send("HanMeimei", "Long time no see!");
	HanMeimei->Send("LiLei", "Yepp!");
	LiLei->Send("HanMeimei", "What is up? I miss U...");
	HanMeimei->Send("LiLei", "Not so bad, Me2");
	Poly->Send("HanMeimei", "Don't forget me!");
	HanMeimei->Send("Poly", "Sorry,Bird");

	LiLei->Send("SongJiang", "《Water Margin》,nice! ");

	_getch();/*等待按键继续*/ 
	return 0;
}

运行情况截图如下：

 

4、应用提示

Mediator模式中Colleague—Mediator之间的通信有两种方式：

一是，Colleague将自身（或其标志性成员变量）作为一个参数传递给Mediator，使其可以识别发送者；

二是，使用观察者Observer模式，将Mediator实现为一个Observer，各个Colleague作为Subject，一旦其状态改变就通知Mediator，再由Mediator将状态通知其它colleague。

本节实例采用第一种方式。第二种方式待学…