C++设计模式之行为型模式：解释器模式（Interpreter） - 详解

解释器模式（Interpreter）是行为型设计模式的一种，它用于定义语言的语法规则并构建解释器来解释该语言的句子。这种模式特别适合处理简单的语法解析场景，如表达式计算、配置文件解析、轻松脚本解释等。

一、核心思想与角色

解释器模式的核心是“将语法规则抽象为类层次结构，依据递归调用解释句子”。其核心角色如下：

角色名称	核心职责
抽象表达式（AbstractExpression）	定义所有表达式的通用接口，声明解释方法（如interpret()）。
终结符表达式（TerminalExpression）	实现语法中终结符的解释（如表达式中的数字、变量），是递归的叶子节点。
非终结符表达式（NonterminalExpression）	实现语法中非终结符的解释（如运算符+、-），包含其他表达式作为子节点，通过递归解释子表达式完成计算。
上下文（Context）	存储解释器的全局信息（如变量映射表），提供给表达式解释时使用。
客户端（Client）	根据语法规则构建抽象语法树（由终结符和非终结符表达式组成），并调用解释方法。

核心思想：将语法规则分解为一系列表达式类，每个类对应一条语法规则；通过组合这些表达式类构建抽象语法树（AST），最终通过递归调用interpret()方法解释整个句子。

二、建立示例（简单算术表达式解析）

假设我们需要解析并计算包含+、-运算符和整数的简单算术表达式（如1 + 2 - 3）。使用解释器模式可将表达式拆解为语法树并计算结果：

#include <iostream>
  #include <string>
    #include <vector>
      #include <memory>
        #include <cctype>
          #include <map>
            // 3. 上下文：存储表达式中的变量和全局信息（此处简化为无变量）
            class Context {
            public:
            // 示例：若有变量，可通过此方法设置（如x=5）
            void setVariable(const std::string& name, int value) {
            variables[name] = value;
            }
            // 获取变量值
            int getVariable(const std::string& name) const {
            auto it = variables.find(name);
            if (it != variables.end()) {
            return it->second;
            }
            return 0; // 变量未定义时返回0
            }
            private:
            std::map<std::string, int> variables; // 变量映射表
              };
              // 1. 抽象表达式
              class AbstractExpression {
              public:
              virtual int interpret(const Context& context) const = 0;
              virtual ~AbstractExpression() = default;
              };
              // 2. 终结符表达式：数字（如"123"）
              class NumberExpression : public AbstractExpression {
              private:
              int number; // 存储解析后的数字
              public:
              NumberExpression(int num) : number(num) {}
              // 解释：直接返回数字值
              int interpret(const Context& context) const override {
              return number;
              }
              };
              // 2. 非终结符表达式：加法（如"a + b"）
              class AddExpression : public AbstractExpression {
              private:
              AbstractExpression* left;  // 左操作数
              AbstractExpression* right; // 右操作数
              public:
              AddExpression(AbstractExpression* l, AbstractExpression* r)
              : left(l), right(r) {}
              // 解释：递归计算左右表达式并相加
              int interpret(const Context& context) const override {
              return left->interpret(context) + right->interpret(context);
              }
              // 析构：释放子表达式
              ~AddExpression() override {
              delete left;
              delete right;
              }
              };
              // 2. 非终结符表达式：减法（如"a - b"）
              class SubtractExpression : public AbstractExpression {
              private:
              AbstractExpression* left;
              AbstractExpression* right;
              public:
              SubtractExpression(AbstractExpression* l, AbstractExpression* r)
              : left(l), right(r) {}
              int interpret(const Context& context) const override {
              return left->interpret(context) - right->interpret(context);
              }
              ~SubtractExpression() override {
              delete left;
              delete right;
              }
              };
              // 辅助工具：表达式解析器（构建抽象语法树）
              class ExpressionParser {
              private:
              // 解析数字（从字符串中提取连续数字字符）
              int parseNumber(const std::string& expr, int& index) {
              int num = 0;
              while (index < expr.size() && isdigit(expr[index])) {
              num = num * 10 + (expr[index] - '0');
              index++;
              }
              return num;
              }
              // 递归解析表达式（简单处理：先加后减，无优先级）
              AbstractExpression* parse(const std::string& expr, int& index) {
              // 解析第一个数字作为左操作数
              AbstractExpression* left = new NumberExpression(parseNumber(expr, index));
              // 循环解析后续的运算符和右操作数
              while (index < expr.size()) {
              // 跳过空格
              while (index < expr.size() && isspace(expr[index])) {
              index++;
              }
              if (index >= expr.size()) break;
              // 解析运算符
              char op = expr[index];
              index++;
              // 跳过空格
              while (index < expr.size() && isspace(expr[index])) {
              index++;
              }
              // 解析右操作数
              AbstractExpression* right = new NumberExpression(parseNumber(expr, index));
              // 根据运算符创建非终结符表达式
              if (op == '+') {
              left = new AddExpression(left, right);
              } else if (op == '-') {
              left = new SubtractExpression(left, right);
              } else {
              // 未知运算符，释放内存并退出
              delete left;
              delete right;
              return nullptr;
              }
              }
              return left;
              }
              public:
              // 解析入口
              AbstractExpression* parse(const std::string& expr) {
              int index = 0;
              // 跳过开头空格
              while (index < expr.size() && isspace(expr[index])) {
              index++;
              }
              return parse(expr, index);
              }
              };
              // 客户端代码：解析并计算表达式
              int main() {
              // 待解析的表达式
              std::string expr1 = "1 + 2 - 3";
              std::string expr2 = "10 + 20 - 5 + 8";
              // 创建解析器和上下文
              ExpressionParser parser;
              Context context;
              // 解析并计算第一个表达式
              AbstractExpression* tree1 = parser.parse(expr1);
              if (tree1) {
              std::cout << "表达式: " << expr1 << " = " << tree1->interpret(context) << std::endl;
                delete tree1;
                }
                // 解析并计算第二个表达式
                AbstractExpression* tree2 = parser.parse(expr2);
                if (tree2) {
                std::cout << "表达式: " << expr2 << " = " << tree2->interpret(context) << std::endl;
                  delete tree2;
                  }
                  return 0;
                  }

三、代码解析

1. 上下文（Context）：
   存储表达式中的变量信息（如x=5），提供setVariable()和getVariable()方法管理变量，供表达式解释时使用（示例中未使用变量，仅展示结构）。

2. 抽象表达式（AbstractExpression）：
   定义了interpret()纯虚方法，所有具体表达式都需实现该方法，完成自身的解释逻辑。

3. 终结符表达式（NumberExpression）：
   对应语法中的“数字”，存储解析后的整数，interpret()直接返回该数字（无需依赖其他表达式）。

4. 非终结符表达式：

   • AddExpression和SubtractExpression分别对应“加法”和“减法”，包含left和right两个子表达式（左、右操作数）。
   • 其interpret()方法通过递归调用子表达式的interpret()，再将结果相加或相减，完成非终结符的解释。

5. 解析器（ExpressionParser）：
   负责将输入的字符串表达式（如"1 + 2 - 3"）转换为抽象语法树（AST）：

   • parseNumber()从字符串中提取数字。
   • 递归parse()方法构建语法树，先解析左操作数，再循环解析运算符和右操作数，通过组合AddExpression和SubtractExpression形成完整的树结构。

6. 客户端使用：
   客户端创建解析器，调用parse()生成语法树，再通过interpret()计算表达式结果，无需关心解析和计算的细节。

四、核心优势与适用场景

优势

1. 易于扩展语法：新增语法规则只需添加对应的表达式类（如新增*运算符只需添加MultiplyExpression），符合开闭原则。
2. 语法清晰：将语法规则分散到多个表达式类中，每个类对应一条规则，代码结构清晰，便于维护。
3. 可定制性：可通过修改或组合表达式类，灵活定制语法解析逻辑。

适用场景

1. 简单语法解析：如部署文件格式解析、简单的数学表达式计算、小型脚本语言解释器。
2. 重复出现的语法：当某类问题频繁出现且可被抽象为容易语法规则时（如正则表达式引擎的部分实现）。
3. 教学或演示：用于展示语法解析的基本原理（如编译原理中的语法分析阶段）。

五、局限性与与其他模式的区别

局限性

1. 复杂语法效率低：对于复杂语法（如C++语言），解释器模式会导致表达式类数量爆炸，且递归解释效率低，此时应使用专业的解析工具（如ANTLR）。
2. 维护成本高：语法规则过多时，表达式类的数量会急剧增加，增加维护难度。

与其他模式的区别

模式	核心差异点
解释器模式	专注于语法解析，将语法规则抽象为类层次结构，通过递归解释句子。
组合模式	构建树形结构表示“部分-整体”关系，统一单个对象和组合对象的使用，不涉及语法解析。
策略模式	封装算法家族，使算法可动态替换，不涉及语法规则和递归解释。

六、实践建议

1. 限制运用场景：仅用于方便语法解析，复杂语法优先利用成熟的解析工具（如YACC、ANTLR）。
2. 结合备忘录模式：对于需要回溯的解析过程（如语法错误恢复），可使用备忘录模式保存解析状态。
3. 缓存解释结果：对于重复出现的表达式，可缓存解释结果，避免重复计算（如频繁使用的公式）。
4. 简化语法设计：设计语法时尽量简洁，避免过多的规则和优先级，降低表达式类的复杂度。

解释器模式的核心价值在于“将语法规则具象化为可扩展的类结构”，它经过递归组合表达式类，实现了对自定义语法的解析。纵然在复杂场景中实用性有限，但在简单语法解析和教学演示中，是一种直观且灵活的设计方案。