面向对象设计模式--解释器模式（C++可执行代码）

解释器模式

（Interpreter）

        解释器 是一种行为设计模式，它是指给定一门语言，定义它的文法的一种表示(如：加减乘除表达式和正则表达式等)，然后再定义一个解释器，该解释器用来解释我们的文法表示(表达式)。

1. 说明 

        解释器模式字面意思，也即解释某些内容的含义。这种设计模式是实际开发中最不容易用到的。比如SQL解析，符号处理引擎，会用到解释器模式，属于更底层的开发人员才会用到的设计模式。

2. 结构

解释器模式的结构

        其中：

        *Abstract Expression声明一个程序的解释操作， 这个接口为抽象语法树中所有的结点所共享。

        *Terminal Expression实现与文法中的终结符相关联的解释操作； 一个句子中的每个终结符需要该类的一个实例。

        *Nonterminal Expression对文法中的每一条规则都需要一个Nonterminal Expression类；为每个符号都维护一个Abstract Expression类型的实例变量； 为文法中的非终结符实现解释(Interpret) 操作。

        *Context包含解释器之外的一些全局信息。

        *Client构建(或被给定) 表示该文法定义的语言中一个特定的句子的抽象语法树， 该抽象语法树由Nonterminal Expression和Terminal Expression的实例装配而成； 调用解释操作。

3. 实现方式

1. 环境角色(Context)：

        用来存储解释器的上下文环境，包含解释器之外的一些全局信息，比如需要解释的文法等。

2. 解释器抽象类角色（Abstract Expression）：

        定义解释器的接口，声明一个所有的具体表达式角色都需要实现的抽象接口，约定解释器的解释操作。

3. 终结符表达式角色（Terminal Expression）：

        解释器具体实现类，实现了抽象表达式角色所要求的接口，用来实现文法中与非终结符相关的操作，文法中的每条规则都对应于一个非终结符表达式。通常在一个解释器模式中只有少数个终结符表达式，其实例可以通过非终结符表达式组成较为复杂的句子。

4. 非终结符表达式角色（Nonterminal Expression）：

        解释器具体实现类，，用来实现文法中与非终结符相关的操作，文法中的每条规则都对应于一个非终结符表达式。其非终结符表达式中即可包含终结符表达式，也可继续包含非终结符表达式，因此解释操作一般通过递归的方式来完成。

5. 代码示例

interpreter.h

 

#ifndef DESIGN_PATTERNS_INTERPRETER_H
#define DESIGN_PATTERNS_INTERPRETER_H
//------------------------------//
#include <iostream>
#include <string>
using namespace std;
//------------------------------//
class Context //"上下文"类
{
public:
	void SetText(string);
	string GetText();

private:
	string text_;
};

//------------------------------//
class Expression //"表示"
{
public:
	virtual ~Expression() {}
	void Interprete(Context*);//解释

protected:
	virtual void Excute(string, double) = 0;//执行
};

class Scale : public Expression //分类
{
private:
	void Excute(string, double);
};

class Note : public Expression //笔记
{
private:
	void Excute(string, double);
};

//------------------------------//
class ExpressionFactory //解释器工厂
{
public:
	Expression* CreateExpression(Context*);//创建解释器
};
//------------------------------//
#endif //DESIGN_PATTERNS_INTERPRETER_H

 

interpreter.c

 

#include "interpreter.h"
#include <sstream>
//------------------------------//
string Context::GetText() 
{
	return text_;
}

void Context::SetText(string text) 
{
	text_ = text;
}

//------------------------------//
void Expression::Interprete(Context *context) 
{
	stringstream ss;
	string key;
	double value;
	string remain_text = context->GetText();
	ss << remain_text;
	ss >> key >> value;
	remain_text = remain_text.substr(remain_text.find(" ") + 1);
	remain_text = remain_text.substr(remain_text.find(" ") + 1);
	if (remain_text.length() < 3)
	{
		remain_text = "";
	}
	context->SetText(remain_text);
	Excute(key, value);
}

void Scale::Excute(string key, double value) 
{
	switch ((int)value)
	{
	case 1:
		cout << "低音 " << endl;
		break;
	case 2:
		cout << "中音 " << endl;
		break;
	case 3:
		cout << "高音 " << endl;
		break;
	default:
		break;
	}
}

void Note::Excute(string key, double value) 
{
	cout << key[0] << endl;
}

//------------------------------//
Expression* ExpressionFactory::CreateExpression(Context *context) 
{
	char key = context->GetText()[0];
	if (key == 'O') 
	{
		return new Scale();
	}
	else 
	{
		return new Note();
	}
}
//------------------------------//

 

Main.c

 

//------------------------------//
#include <iostream>
#include "interpreter.h"
using namespace std;
//------------------------------//
// Created by Cls on 2024/04/01.
//------------------------------//
int main(int argc, char *argv[])
{
	Context *context_;
	ExpressionFactory *expression_factory_;
	Expression *expression_;
	//-----------------//
	expression_factory_ = new ExpressionFactory();
	context_ = new Context();
	context_->SetText("O 2 E 0.5 G 0.5 A 3");
	while (context_->GetText().length()) 
	{
		expression_ = expression_factory_->CreateExpression(context_);
		expression_->Interprete(context_);
		delete expression_;
	}
	//-----------------//
	cout << "------------------" << endl;
	//-----------------//
	delete context_;
	delete expression_factory_;
	//-----------------//
	return 0;
}
//------------------------------//

 

打印输出

 

6. 应用场景

        当语言的文法较为简单，且执行效率、性能要求不高。

        当问题重复出现，相似的处理逻辑，可抽象为一种简单语言，且可以用一种简单的语言来进行表达时。

        当一个语言需要解释执行，并且语言中的句子可以表示为一个抽象语法树的时候，如XML文档解释。

7. 优缺点

        √ 可扩展性强：可以通过扩展语言中的表达式和语法规则来实现新的行为，可以通过继承机制来改变和扩展文法。

        √ 易于实现文法：解释器模式实现相对简单，只需要实现抽象表达式和具体表达式类即可，而定义抽象语法树中各个节点地类的实现大体类似。

        √ 易于拓展语法规则：解释器模式可以让用户较为方便的增加新类型的表达式，增加新的表达式时无需对现有的表达式进行修改，符合开闭原则。

        × 执行效率较低：解释器模式中通常使用大量的循环和递归调用，当要解释的句子较复杂时，其运行速度很慢，且代码的调试过程也比较麻烦。

        × 会引起类膨胀：解释器模式中的每条规则至少需要定义一个类，当包含的文法规则很多时，类的个数将急剧增加，导致系统难以管理与维护。

        × 可应用的场景比较少：在软件开发中，需要定义语言文法的应用实例非常少，所以这种模式很少被使用到。

        × 复杂的文法比较难维护：对于复杂文法难以维护，其每一条规则至少需要定义一个类，若一个语言包含太多文法规则，则可能难以管理和维护，此时可以考虑使用语法分析程序等方式来取代解释器模式。

8. 与其他模式的关系

解释器模式的结构与组合模式相似，不过其包含的组成元素比组合模式多，而且组合模式是对象结构型模式，而解释器模式是类行为型模式。