我所理解的设计模式（C++实现）——解释器模式（Interpreter Pattern）

最新推荐文章于 2025-09-29 09:16:15 发布

原创最新推荐文章于 2025-09-29 09:16:15 发布 · 1w 阅读

6 ·

CC 4.0 BY-SA版权

文章标签：

#解释器模式 #Interpreter Pattern #设计模式 #C++

我所理解的设计模式专栏收录该内容

25 篇文章

订阅专栏

本文探讨了如何使用解释器模式处理复杂自然语言，包括类图、实例、适用性、优缺点及总论，提供了关于如何在项目中应用此模式的见解。

概述：

未来机器智能化已然成为趋势，现在手机都能听懂英语和普通话，那我大中华几万种方言的被智能化也许也是趋势，我们的方言虽然和普通话相似，但是还是不一样的。这可能需要一个新的语法分析器来帮助我们。

我们的解释器模式就是描述了如何为简单的语言定义一个文法，如何在该语言中表示一个句子，以及如何解释这些句子。

但是解释一门自然语言是复杂的过程，我们以加减运算为例子来详细解释解释器模式。

类图和实例：

抽象表达式角色(AbstractExpression)：声明一个抽象的解释操作，这个接口为所有具体表达式角色都要实现的。
终结符表达式角色(TerminalExpression)：实现与文法中的元素相关联的解释操作，通常一个解释器模式中只有一个终结符表达式，但有多个实例对应不同的终结符，
终结符就是语言中用到的基本元素，一般不能再被分解，如: x -> xa，这里a是终结符，因为没有别的规则可以把a变成别的符号，不过x可以变成别的符号，所以x是非终结符。
非终结符表达式角色(NonterminalExpression)：文法中的每条规则对应于一个非终结表达式，非终结表达式根据逻辑的复杂程度而增加，原则上每个文法规则都对应一个非终结符表达式。
环境角色(Context)：包含解释器之外的一些全局信息。

实例：

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

class Context
{
private:
	map<string, int> valueMap;

public:
	void addValue(string key,int value)
	{       
		valueMap.insert(std::pair<string,int>(key,value));
	}

	int getValue(string key)
	{
		return valueMap[key];
	}
};

class AbstractExpression
{
public :
	 virtual int interpreter(Context context) = 0;
};

class AddNonterminalExpression : public AbstractExpression
{
private :
	AbstractExpression *left;
	AbstractExpression *right;

public:
	AddNonterminalExpression(AbstractExpression *left, AbstractExpression *right)
	{
		this->left = left;
		this->right = right;
	}

	int interpreter(Context context)
	{
		return this->left->interpreter(context) + this->right->interpreter(context);
	}

};

class SubtractNonterminalExpression : public AbstractExpression
{
private :
	AbstractExpression *left;
	AbstractExpression *right;

public:
	SubtractNonterminalExpression(AbstractExpression *left, AbstractExpression *right)
	{
		this->left = left;
		this->right = right;
	}

	int interpreter(Context context)
	{
		return this->left->interpreter(context) - this->right->interpreter(context);
	}

};

class TerminalExpression : public AbstractExpression
{
private :
	int i;

public :
	TerminalExpression(int i)
	{
		this->i = i;
	}

	int interpreter(Context context)
	{
		return this->i;
	}
};

int main(){  
	//a-b+c
	Context context;
	context.addValue("a", 7);
	context.addValue("b", 8);
	context.addValue("c", 2);

	SubtractNonterminalExpression *subtractValue = new SubtractNonterminalExpression(new TerminalExpression(
		context.getValue("a")), new TerminalExpression(context.getValue("b")));

	AddNonterminalExpression *addValue = new AddNonterminalExpression(subtractValue, new TerminalExpression(
		context.getValue("c")));

	cout<< addValue->interpreter(context);

	return 0;  
}