【第23节】C++设计模式(行为模式)-Interpreter(解释器)模式

一、问题背景

在一些应用中，系统会提供内建（Build-In）的脚本或宏语言，允许用户定义他们能够在系统中执行的操作。Interpreter 模式的目的就是为用户提供一种定义语言的语法表示，并通过解释器来解释语言中的句子。这种模式的核心思想是将语言的语法规则表示为类，并通过这些类来解析和执行用户输入的语句。

Interpreter 模式为构建语法解释器提供了一个框架。例如，开发了一个编译系统，该系统可以使用 Interpreter 模式来实现语法解析功能。Interpreter 模式不仅适用于编译器设计，还可以用于解析配置文件、查询语言、规则引擎等场景。

二、模式选择

Interpreter 模式的典型结构图如下：

在 Interpreter 模式中，主要包含以下几个角色：

（1）AbstractExpression（抽象表达式）：定义解释器的接口，包含一个 `Interpret` 方法。
（2）TerminalExpression（终结符表达式）：实现与文法中的终结符相关的解释操作。
（3）NonterminalExpression（非终结符表达式）：实现与文法中的非终结符相关的解释操作，通常包含对其他表达式的引用。
（4）Context（上下文）：包含解释器需要的全局信息。

通过这种设计，Interpreter 模式将语法规则表示为类的层次结构，从而实现对语句的解释。

三、代码实现

下面我们将通过一个完整的 C++ 代码示例来展示如何实现 Interpreter 模式。

代码片段 1：Context.h

// Context.h
#ifndef _CONTEXT_H_
#define _CONTEXT_H_// Context 类：为解释过程提供全局信息
class Context {
public:Context();~Context();
protected:
private:
};#endif //~_CONTEXT_H_

代码片段 2：Context.cpp

// Context.cpp
#include "Context.h"// Context 类的实现
Context::Context() {// 构造函数
}Context::~Context() {// 析构函数
}

代码片段 3：Interpret.h

// Interpret.h
#ifndef _INTERPRET_H_
#define _INTERPRET_H_#include "Context.h"
#include <string>
using namespace std;// AbstractExpression 类：定义解释器的接口
class AbstractExpression {
public:virtual ~AbstractExpression();virtual void Interpret(const Context& c) = 0;  // 解释方法
protected:AbstractExpression();
private:
};// TerminalExpression 类：终结符表达式
class TerminalExpression : public AbstractExpression {
public:TerminalExpression(const string& statement);  // 构造函数~TerminalExpression();void Interpret(const Context& c);  // 实现解释方法
protected:
private:string _statement;  // 终结符内容
};// NonterminalExpression 类：非终结符表达式
class NonterminalExpression : public AbstractExpression {
public:NonterminalExpression(AbstractExpression* expression, int times);  // 构造函数~NonterminalExpression();void Interpret(const Context& c);  // 实现解释方法
protected:
private:AbstractExpression* _expression;  // 子表达式int _times;  // 重复次数
};#endif //~_INTERPRET_H_

代码片段 4：Interpret.cpp

// Interpret.cpp
#include "Interpret.h"
#include <iostream>
using namespace std;// AbstractExpression 类的实现
AbstractExpression::AbstractExpression() {// 构造函数
}AbstractExpression::~AbstractExpression() {// 析构函数
}void AbstractExpression::Interpret(const Context& c) {// 默认实现为空
}// TerminalExpression 类的实现
TerminalExpression::TerminalExpression(const string& statement) {this->_statement = statement;  // 初始化终结符内容
}TerminalExpression::~TerminalExpression() {// 析构函数
}void TerminalExpression::Interpret(const Context& c) {// 解释终结符cout << this->_statement << " TerminalExpression" << endl;
}// NonterminalExpression 类的实现
NonterminalExpression::NonterminalExpression(AbstractExpression* expression, int times) {this->_expression = expression;  // 初始化子表达式this->_times = times;  // 初始化重复次数
}NonterminalExpression::~NonterminalExpression() {// 析构函数
}void NonterminalExpression::Interpret(const Context& c) {// 解释非终结符for (int i = 0; i < _times; i++) {this->_expression->Interpret(c);  // 重复解释子表达式}
}

代码片段 5：main.cpp

// main.cpp
#include "Context.h"
#include "Interpret.h"
#include <iostream>
using namespace std;int main(int argc, char* argv[]) {// 创建上下文对象Context* c = new Context();// 创建终结符表达式AbstractExpression* te = new TerminalExpression("hello");// 创建非终结符表达式AbstractExpression* nte = new NonterminalExpression(te, 2);// 解释非终结符表达式nte->Interpret(*c);// 释放内存delete nte;delete te;delete c;return 0;
}

代码说明

（1）Context 类：为解释过程提供全局信息。在实际应用中，可以扩展此类以存储解释器需要的额外数据。
（2）AbstractExpression 类：定义解释器的接口，所有具体表达式类都需要实现 `Interpret` 方法。
（3）TerminalExpression 类：实现与终结符相关的解释操作。例如，在解析算术表达式时，终结符可以是数字或变量。
（4）NonterminalExpression 类：实现与非终结符相关的解释操作。例如，在解析算术表达式时，非终结符可以是加法或乘法操作。