设计模式——解释器模式（C++实现）

解释器模式简介

            解释器模式（Interpreter Pattern）提供了评估语言的语法或表达式的方式，属于行为型模式。

            这种模式实现了一个表达式接口，该接口解释一个特定的上下文。常被用在 SQL 解析、符号处理引擎等。

适用场景

           1、当有一个语言需要解释执行 , 并且你可将该语言中的句子表示为一个抽象语法树时，可使用解释器模式。而当存在以下情况时该模式效果最好：
                 1.1、该文法简单。对于复杂的文法 , 文法的类层次变得庞大而无法管理。此时语法分析程序生
成器这样的工具是更好的选择。它们无需构建抽象语法树即可解释表达式 , 这样可以节省空间而且还可能节省时间。
                 1.2、效率不是一个关键问题。最高效的解释器通常不是通过直接解释语法分析树实现的 , 而是首先将它们转换成另一种形式。例如，正则表达式通常被转换成状态机。但即使在这种情况下, 转换器仍可用解释器模式实现, 该模式仍是有用的。
 

采用菜鸟教程的例子，这里用C++实现

#include<iostream>
#include<string>

using namespace std;

//创建一个表达式抽象接口类Expression
class Expression
{
public:
	Expression() {};
	virtual ~Expression() {};
	virtual bool interpret(string context)=0;
};

//创建实现了抽象接口Expression的实体类TerminalExpression
class TerminalExpression :public Expression
{
public:
	TerminalExpression(string data);
	~TerminalExpression() {};
	bool interpret(string context);
private:
	string data;
};

TerminalExpression::TerminalExpression(string data)
{
	this->data = data;
}

bool TerminalExpression::interpret(string context)
{
	if (context.find(data) != string::npos)
	{
		return true;
	}
	return false;
}

//创建实现了抽象接口Expression的实体类OrExpression
class OrExpression :public Expression
{
public:
	OrExpression(Expression *texpr1, Expression *texpr2);
	~OrExpression() {};
	bool interpret(string context);
private:
	Expression *expr1;
	Expression *expr2;
};

OrExpression::OrExpression(Expression *texpr1, Expression *texpr2)
{
	this->expr1 = texpr1;
	this->expr2 = texpr2;
}

bool OrExpression::interpret(string context)
{
	if (expr1->interpret(context)|| expr2->interpret(context))
	{
		return true;
	}
	return false;
}

//创建实现了抽象接口Expression的实体类AndExpression
class AndExpression :public Expression
{
public:
	AndExpression(Expression *texpr1, Expression *texpr2);
	~AndExpression() {};
	bool interpret(string context);
private:
	Expression *expr1;
	Expression *expr2;
};

AndExpression::AndExpression(Expression *texpr1, Expression *texpr2)
{
	this->expr1 = texpr1;
	this->expr2 = texpr2;
}

bool AndExpression::interpret(string context)
{
	if (expr1->interpret(context) && expr2->interpret(context))
	{
		return true;
	}
	return false;
}


int main()
{
	//规则：Robert 和 John 是男性
	Expression *robert =(Expression *) new TerminalExpression("Robert");
	Expression *john = (Expression *) new TerminalExpression("John");
	Expression *isMale = (Expression *)new OrExpression(robert, john);
	
	//规则：Julie 是一个已婚的女性
	Expression *julie = (Expression *)  new TerminalExpression("Julie");
	Expression *married = (Expression *)  new TerminalExpression("Married");
	Expression *isMarriedWoman = (Expression *)  new AndExpression(julie, married);

	string result1 = (isMale->interpret("John")) ? "true" : "false";
	cout << "John is male? " << result1 << endl;
	string result2 = (isMarriedWoman->interpret("Married Julie")) ? "true" : "false";
	cout << "Julie is a married women? " << result2 << endl;
	
	delete robert;
	robert = NULL;

	delete john;
	john = NULL;

	delete isMale;
	isMale = NULL;

	delete julie;
	julie = NULL;

	delete married;
	married = NULL;

	delete isMarriedWoman;
	isMarriedWoman = NULL;
	system("pause");
	return 0;
}

在visual studio 2015上运行结果：