【第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 类：实现与非终结符相关的解释操作。例如，在解析算术表达式时，非终结符可以是加法或乘法操作。

四、总结讨论

Interpreter 模式在以下场景中非常有用：

（1）解析配置文件：例如 XML、JSON 等格式的配置文件。
（2）查询语言：例如 SQL 查询解析器。
（3）规则引擎：例如业务规则的解释和执行。

在实际开发中，Interpreter 模式可以与其他设计模式结合使用。例如：
（1）使用 **Flyweight 模式** 共享终结符对象，减少内存占用。
（2）使用 **Composite 模式** 构建复杂的语法树。

        Interpreter 模式通过将语法规则表示为类的层次结构，提供了一种灵活的方式来解释语言中的句子。这种模式不仅适用于编译器设计，还可以用于解析配置文件、查询语言、规则引擎等场景。通过 Interpreter 模式，我们可以将复杂的语法解析逻辑分解为简单的类，从而提高代码的可维护性和可扩展性。