C++解释器模式实战：构建可扩展的算术表达式求值引擎

1. 项目概述：为什么我们需要解释器模式？

在软件开发中，我们经常会遇到一些需要解析和执行特定“语言”或“规则”的场景。这里的“语言”不一定是像Python或C++这样的通用编程语言，它可能是一套简单的算术表达式（比如"1 + 2 * (3 - 4)"）、一个业务规则（比如"VIP用户 && 订单金额 > 1000"）、一个查询语句（比如"name = '张三' AND age > 25"），甚至是一个机器人指令序列。当这些规则或表达式以字符串的形式出现，并且需要被动态地解释和执行时，我们该怎么办？

最直接的想法可能是写一个巨大的if-else或switch-case语句，或者用正则表达式进行复杂的匹配和解析。对于非常简单的规则，这或许可行。但一旦规则变得复杂、需要组合嵌套、或者未来可能频繁变更和扩展，这种“硬编码”的方式就会迅速变得难以维护，代码会臃肿不堪，逻辑会像一团乱麻。

解释器模式（Interpreter Pattern）就是为了优雅地解决这类问题而生的。它属于行为型设计模式，其核心思想是为一种特定的“语言”定义其文法的一种表示，并定义一个解释器，利用该表示来解释语言中的句子。简单说，就是把要解释的语句，转换成一个由对象组成的抽象语法树（AST），然后通过遍历这棵树来执行解释操作。每个语法规则都对应一个类，这使得添加新的语法规则就像添加新的类一样简单，完美符合“开闭原则”。

在C++中实现解释器模式，尤其能体现其面向对象和编译时多态的优势。C++的强类型系统、继承和虚函数机制，为构建清晰的语法树节点类层次结构提供了坚实的基础。无论是实现一个简单的计算器，还是为一个领域特定语言（DSL）构建后端，解释器模式都是一个非常值得掌握的强大工具。接下来，我将以一个可运行的、渐进的例子，带你从零开始，深入理解解释器模式的原理，并用C++一步步实现它。

2. 核心概念与模式结构拆解

在动手写代码之前，我们必须先吃透解释器模式的几个核心概念和它的标准UML结构。理解这些是写出优雅、灵活代码的关键。

2.1 关键角色解析

解释器模式通常涉及以下几个关键角色，它们共同协作完成解释任务：

1. 抽象表达式（AbstractExpression）：这是一个抽象基类（在C++中通常是一个包含纯虚函数的类），它声明了一个Interpret（或Evaluate）接口。所有具体的语法规则类都必须实现这个接口。它代表了语法树中所有节点的共同协议。

2. 终结符表达式（TerminalExpression）：这是实现了AbstractExpression接口的具体类。终结符是文法中的基本元素，不能再被分解。在算术表达式中，数字常量（如5,10.2）就是典型的终结符。它的Interpret方法通常直接返回其存储的值。

3. 非终结符表达式（NonterminalExpression）：同样是AbstractExpression的具体子类。非终结符代表文法中的组合规则，它由一个或多个其他表达式（可以是终结符，也可以是非终结符）组合而成。例如，加法表达式AddExpression就是非终结符，它包含左、右两个子表达式。它的Interpret方法需要递归地调用其子表达式的Interpret方法，并根据自身的规则（如加法运算）组合结果。

4. 上下文（Context）：这是一个可选但常用的角色，它包含了解释器之外的一些全局信息。例如，在解释一个变量表达式时，我们需要一个上下文来存储和查找变量的值。上下文可以作为一个参数传递给所有表达式的Interpret方法。

5. 客户端（Client）：负责构建（或由其他解析器，如语法分析器，为其构建）代表特定句子的抽象语法树。这个语法树由TerminalExpression和NonterminalExpression的实例构成。随后，客户端调用语法树根节点的Interpret方法，触发整个解释过程。

2.2 工作流程与数据流

模式的典型工作流程如下：

• 客户端获得一个需要解释的语句（字符串）。
• 客户端调用一个解析器（这部分通常不属于解释器模式本身，模式关注的是解释而非解析），将字符串转换为一个由AbstractExpression对象构成的抽象语法树（AST）。树的叶子节点是TerminalExpression，中间节点是NonterminalExpression。
• 客户端调用 AST 根节点的Interpret(Context)方法。
• 每个NonterminalExpression节点在其Interpret方法中，递归地调用其子节点的Interpret方法，获取子结果，然后执行自己的操作（如加、减、乘、除）。
• 递归最终到达TerminalExpression节点，它们直接返回一个具体值（如数字、变量值）。
• 结果沿着调用链向上返回，最终根节点返回整个句子的解释结果。

注意：严格区分“解析”和“解释”。解释器模式主要解决的是“解释”已构建好的语法树。将字符串“解析”成语法树是另一个复杂的问题，通常使用词法分析器（Lexer）和语法分析器（Parser）来完成，如使用递归下降法、ANTLR等工具。在简单的教学示例中，我们可能会简化解析过程，但理解这一区别至关重要。

3. 实战：用C++实现一个算术表达式解释器

理论说得再多，不如一行代码。让我们来实现一个能够处理加、减、乘、除和括号的整数算术表达式解释器。我们将遵循从简到繁的原则，先构建核心表达式类，再实现解析逻辑。

3.1 定义表达式抽象接口与终结符

首先，定义所有表达式节点的基类。

// Expression.h #ifndef INTERPRETER_PATTERN_EXPRESSION_H #define INTERPRETER_PATTERN_EXPRESSION_H class Context; // 前向声明，目前我们的简单例子可能不需要复杂的上下文 class Expression { public: virtual ~Expression() = default; // 解释/求值接口，返回表达式的计算结果 virtual int interpret() const = 0; }; #endif //INTERPRETER_PATTERN_EXPRESSION_H

接着，实现最简单的终结符表达式：数字。它只存储一个整数值。

// NumberExpression.h #ifndef INTERPRETER_PATTERN_NUMBEREXPRESSION_H #define INTERPRETER_PATTERN_NUMBEREXPRESSION_H #include "Expression.h" class NumberExpression : public Expression { private: int value_; public: explicit NumberExpression(int value) : value_(value) {} int interpret() const override { return value_; // 终结符直接返回值 } }; #endif //INTERPRETER_PATTERN_NUMBEREXPRESSION_H

3.2 实现非终结符：二元运算表达式

现在实现非终结符。我们创建一个二元运算表达式的基类，封装左右操作数的共性。

// BinaryExpression.h #ifndef INTERPRETER_PATTERN_BINARYEXPRESSION_H #define INTERPRETER_PATTERN_BINARYEXPRESSION_H #include "Expression.h" #include <memory> class BinaryExpression : public Expression { protected: std::shared_ptr<Expression> left_; std::shared_ptr<Expression> right_; public: BinaryExpression(std::shared_ptr<Expression> left, std::shared_ptr<Expression> right) : left_(std::move(left)), right_(std::move(right)) {} // interpret() 方法由具体子类实现 }; #endif //INTERPRETER_PATTERN_BINARYEXPRESSION_H

然后，实现具体的加法、减法、乘法、除法表达式。它们继承自BinaryExpression，并在interpret方法中定义具体的运算逻辑。

// AddExpression.h #ifndef INTERPRETER_PATTERN_ADDEXPRESSION_H #define INTERPRETER_PATTERN_ADDEXPRESSION_H #include "BinaryExpression.h" class AddExpression : public BinaryExpression { public: using BinaryExpression::BinaryExpression; // 继承构造函数 int interpret() const override { // 递归解释左子树和右子树，然后相加 return left_->interpret() + right_->interpret(); } }; // SubtractExpression, MultiplyExpression, DivideExpression 类似 // ...

减法、乘法、除法类的代码结构完全类似，只需更改interpret方法中的运算符。这里以乘法为例：

// MultiplyExpression.h class MultiplyExpression : public BinaryExpression { public: using BinaryExpression::BinaryExpression; int interpret() const override { return left_->interpret() * right_->interpret(); } };

实操心得：使用智能指针管理资源。在C++中构建树形结构，手动管理内存极易出错。使用std::shared_ptr<Expression>来自动管理表达式节点的生命周期，是更安全、现代的做法。这避免了深拷贝的复杂性，也防止了内存泄漏。std::unique_ptr也可行，但在构建语法树时，一个节点可能被多个父节点引用（虽然在我们这个简单文法中不常见），shared_ptr更灵活。

3.3 构建语法树与解释执行

有了这些表达式类，我们现在可以手动“组装”一个语法树来解释一个表达式，例如(5 + 2) * 3。

// manual_build.cpp #include <iostream> #include <memory> #include "NumberExpression.h" #include "AddExpression.h" #include "MultiplyExpression.h" int main() { // 构建表达式: (5 + 2) * 3 // 叶子节点：数字 5, 2, 3 auto five = std::make_shared<NumberExpression>(5); auto two = std::make_shared<NumberExpression>(2); auto three = std::make_shared<NumberExpression>(3); // 非终结符节点：5 + 2 auto addExpr = std::make_shared<AddExpression>(five, two); // 根节点：(5 + 2) * 3 auto multiplyExpr = std::make_shared<MultiplyExpression>(addExpr, three); // 解释执行 int result = multiplyExpr->interpret(); std::cout << "The result of (5 + 2) * 3 is: " << result << std::endl; // 输出 21 return 0; }

运行这个程序，你会得到正确的结果21。这个过程清晰地展示了解释器模式的核心：将复杂的表达式分解为对象树，并通过多态递归来求值。手动构建树验证了我们的表达式类设计是正确的。但这显然不实用，我们需要一个解析器来将字符串"(5+2)*3"自动转换成这棵树。

4. 关键难点：从字符串到语法树的解析器实现

构建语法树是解释器模式中最具挑战性的部分。我们需要一个语法分析器（Parser）。对于简单的算术表达式，我们可以使用“递归下降分析法”，这是一种直观且易于手写的方法。它要求文法满足一定的条件（如消除左递归），我们使用的四则运算文法可以描述为：

Expression -> Term ([+-] Term)* Term -> Factor ([*/] Factor)* Factor -> Number | '(' Expression ')'

这里，Expression处理加减，Term处理乘除，Factor处理数字和括号表达式。*表示0次或多次重复。

4.1 词法分析器（Lexer）实现

在语法分析前，需要先将输入字符串拆分成一个个独立的词法单元（Token），如数字、运算符、括号。这个过程叫词法分析。

// Lexer.h #ifndef INTERPRETER_PATTERN_LEXER_H #define INTERPRETER_PATTERN_LEXER_H #include <string> #include <cctype> enum class TokenType { NUMBER, PLUS, // + MINUS, // - MULTIPLY, // * DIVIDE, // / LPAREN, // ( RPAREN, // ) END // 结束 }; struct Token { TokenType type; int value; // 仅当 type == NUMBER 时有效 Token(TokenType t, int v = 0) : type(t), value(v) {} }; class Lexer { private: std::string input_; size_t pos_; char currentChar_; public: explicit Lexer(const std::string& input) : input_(input), pos_(0) { currentChar_ = input_.empty() ? '\0' : input_[0]; } void advance() { pos_++; currentChar_ = (pos_ < input_.size()) ? input_[pos_] : '\0'; } Token getNextToken() { while (currentChar_ != '\0' && std::isspace(currentChar_)) { advance(); // 跳过空白字符 } if (currentChar_ == '\0') { return Token(TokenType::END); } if (std::isdigit(currentChar_)) { return parseNumber(); } switch (currentChar_) { case '+': advance(); return Token(TokenType::PLUS); case '-': advance(); return Token(TokenType::MINUS); case '*': advance(); return Token(TokenType::MULTIPLY); case '/': advance(); return Token(TokenType::DIVIDE); case '(': advance(); return Token(TokenType::LPAREN); case ')': advance(); return Token(TokenType::RPAREN); default: throw std::runtime_error("Invalid character: " + std::string(1, currentChar_)); } } private: Token parseNumber() { std::string numberStr; while (currentChar_ != '\0' && std::isdigit(currentChar_)) { numberStr += currentChar_; advance(); } int value = std::stoi(numberStr); return Token(TokenType::NUMBER, value); } }; #endif //INTERPRETER_PATTERN_LEXER_H

4.2 递归下降语法分析器（Parser）实现

Parser类将利用Lexer产生的Token流，按照前面定义的文法规则，递归地构建出表达式语法树。

// Parser.h #ifndef INTERPRETER_PATTERN_PARSER_H #define INTERPRETER_PATTERN_PARSER_H #include "Lexer.h" #include "Expression.h" #include "NumberExpression.h" #include "AddExpression.h" #include "SubtractExpression.h" #include "MultiplyExpression.h" #include "DivideExpression.h" #include <memory> class Parser { private: Lexer lexer_; Token currentToken_; public: explicit Parser(const std::string& input) : lexer_(input) { currentToken_ = lexer_.getNextToken(); } std::shared_ptr<Expression> parse() { return expr(); // 从最高级的 Expression 规则开始解析 } private: // 匹配当前token类型，并获取下一个token void eat(TokenType type) { if (currentToken_.type == type) { currentToken_ = lexer_.getNextToken(); } else { throw std::runtime_error("Unexpected token"); } } // Expression -> Term ([+-] Term)* std::shared_ptr<Expression> expr() { auto node = term(); // 解析第一个 Term while (currentToken_.type == TokenType::PLUS || currentToken_.type == TokenType::MINUS) { Token op = currentToken_; if (op.type == TokenType::PLUS) { eat(TokenType::PLUS); node = std::make_shared<AddExpression>(node, term()); } else if (op.type == TokenType::MINUS) { eat(TokenType::MINUS); node = std::make_shared<SubtractExpression>(node, term()); } } return node; } // Term -> Factor ([*/] Factor)* std::shared_ptr<Expression> term() { auto node = factor(); // 解析第一个 Factor while (currentToken_.type == TokenType::MULTIPLY || currentToken_.type == TokenType::DIVIDE) { Token op = currentToken_; if (op.type == TokenType::MULTIPLY) { eat(TokenType::MULTIPLY); node = std::make_shared<MultiplyExpression>(node, factor()); } else if (op.type == TokenType::DIVIDE) { eat(TokenType::DIVIDE); node = std::make_shared<DivideExpression>(node, factor()); } } return node; } // Factor -> Number | '(' Expression ')' std::shared_ptr<Expression> factor() { Token token = currentToken_; if (token.type == TokenType::NUMBER) { eat(TokenType::NUMBER); return std::make_shared<NumberExpression>(token.value); } else if (token.type == TokenType::LPAREN) { eat(TokenType::LPAREN); auto node = expr(); // 递归解析括号内的表达式 eat(TokenType::RPAREN); return node; } else { throw std::runtime_error("Unexpected token in factor"); } } }; #endif //INTERPRETER_PATTERN_PARSER_H

4.3 整合与测试：完整的表达式求值程序

现在，我们将所有部分整合起来，创建一个完整的、可以从字符串表达式求值的程序。

// main.cpp #include <iostream> #include <string> #include "Parser.h" int main() { std::string input; std::cout << "Enter an arithmetic expression (e.g., (5+2)*3-8/4): "; std::getline(std::cin, input); try { Parser parser(input); std::shared_ptr<Expression> syntaxTree = parser.parse(); int result = syntaxTree->interpret(); std::cout << "Result: " << result << std::endl; } catch (const std::exception& e) { std::cerr << "Error: " << e.what() << std::endl; } return 0; }

编译并运行这个程序，输入(5+2)*3-8/4，它会正确计算出结果19。至此，我们完成了一个功能完整的、采用解释器模式的算术表达式求值器。

注意事项：关于除零与错误处理。我们当前的实现非常基础，缺乏健壮的错误处理。例如，除法表达式在interpret()时如果遇到右子表达式结果为0，会导致除零错误。在实际项目中，必须在DivideExpression::interpret()中加入检查，并抛出明确的异常。同样，Parser和Lexer中的错误也应该被更优雅地捕获和报告，而不是简单地throw std::runtime_error。

5. 模式优缺点与适用场景深度分析

通过上面的实践，我们已经切身感受到了解释器模式的运作方式。现在，让我们跳出代码，从更高维度审视这个模式的利弊，以及它究竟适合用在什么地方。

5.1 优势：为何选择解释器模式？

1. 易于改变和扩展语法：这是解释器模式最大的优点。要扩展语言（例如增加取模%运算符或幂运算^），你只需要增加新的表达式类（如ModExpression,PowerExpression），并在语法分析器中增加对应的解析逻辑即可。无需修改现有的表达式类，符合开闭原则。
2. 易于实现语法：对于简单的文法，实现起来相对直接。每个语法规则都映射到一个类，类的层次结构清晰反映了文法的层次结构，代码可读性好。
3. 适合领域特定语言（DSL）：当你需要为特定领域（如财务计算、游戏关卡脚本、硬件配置）创建一种小型的、专用的语言时，解释器模式提供了一种清晰的实现路径。你可以用对象树来精确表示DSL的语句。

5.2 劣势：何时应避免使用？

1. 复杂的文法难以维护：解释器模式为文法中的每一条规则都至少定义一个类。当文法非常复杂、包含大量规则时（例如，一个完整的编程语言），类的数量会爆炸式增长，导致系统变得极其庞大和难以管理。此时，使用词法/语法分析器生成器（如ANTLR, Yacc/Bison）是更专业的选择。
2. 效率问题：解释执行通常比直接编译成机器码或字节码再执行要慢。对于性能要求极高的场景，解释器模式可能不是最佳选择。不过，对于大多数配置解析或业务规则判断的场景，其性能通常是可接受的。
3. 调试困难：由于解释过程是通过递归遍历对象树进行的，调试可能比线性的过程式代码更复杂，尤其是当树很深的时候。

5.3 经典适用场景

根据其特点，解释器模式在以下场景中能大放异彩：

• 简单语言解释器：如我们实现的算术表达式、布尔表达式、正则表达式（核心引擎）的解释器。
• 业务规则引擎：在需要动态配置复杂业务规则的系统中。例如，一个促销活动系统，规则可能是用户等级为金牌 AND (商品类别为电子产品 OR 订单金额 > 1000)。可以将每条规则定义为一个表达式对象，灵活组合。
• SQL解析（部分）：虽然完整的SQL解析器非常复杂，但解释器模式的思想可以用于处理SQL语句中的WHERE条件子句等部分。
• 符号处理与公式计算：在科学计算、金融建模软件中，需要解释用户输入的数学公式。
• 编译器/解释器的前端：在实现编程语言时，抽象语法树（AST）的节点设计本身就广泛运用了解释器模式的思想。后续的语义分析、代码生成或直接解释执行，都是基于这颗AST进行的。

6. 高级话题与性能优化实践

在掌握了基础实现后，我们可以探讨一些更深入的话题，让我们的解释器更强大、更高效。

6.1 引入上下文（Context）处理变量

之前的例子只能处理常量。一个更有用的解释器应该能处理变量，比如表达式x + y * 2。这就需要引入Context类来存储变量名到值的映射。

// Context.h #ifndef INTERPRETER_PATTERN_CONTEXT_H #define INTERPRETER_PATTERN_CONTEXT_H #include <unordered_map> #include <string> class Context { private: std::unordered_map<std::string, int> variables_; public: 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; } throw std::runtime_error("Undefined variable: " + name); } };

然后，我们需要一个新的终结符表达式VariableExpression。

// VariableExpression.h class VariableExpression : public Expression { private: std::string name_; const Context& context_; // 持有对上下文的引用 public: VariableExpression(const std::string& name, const Context& ctx) : name_(name), context_(ctx) {} int interpret() const override { return context_.getVariable(name_); // 从上下文查询值 } };

相应地，Expression的interpret接口需要修改为接受Context参数：virtual int interpret(const Context&) const = 0;，所有子类都需要调整。Parser在遇到标识符时需要生成VariableExpression节点。这样，解释器就具备了处理变量的能力。

6.2 使用访问者模式（Visitor Pattern）分离算法

在复杂的解释器中，我们可能需要对语法树进行多种操作，不仅仅是求值（interpret）。例如，我们可能还想进行类型检查、代码优化、格式化打印等。如果把这些操作都塞进每个表达式类的interpret方法里，会导致类职责过重，且每增加一种新操作就要修改所有类。

这时，访问者模式可以完美解决这个问题。我们可以为每种操作定义一个访问者（Visitor），让访问者来遍历语法树并执行操作，而表达式类只负责接受访问者。

// 表达式基类增加接受访问者的接口 class Expression { public: virtual ~Expression() = default; virtual int interpret(const Context&) const = 0; // 新增：接受访问者 virtual void accept(class Visitor& visitor) const = 0; }; // 访问者基类 class Visitor { public: virtual void visit(const NumberExpression&) = 0; virtual void visit(const AddExpression&) = 0; virtual void visit(const VariableExpression&) = 0; // ... 为每种表达式类型声明一个visit方法 }; // 在具体表达式类中实现accept void NumberExpression::accept(Visitor& visitor) const { visitor.visit(*this); } void AddExpression::accept(Visitor& visitor) const { // 先访问左子树，再访问右子树，最后访问自己 left_->accept(visitor); right_->accept(visitor); visitor.visit(*this); } // 实现一个求值访问者 class EvaluateVisitor : public Visitor { private: const Context& context_; std::stack<int> valueStack_; // 用栈来存储中间计算结果 public: EvaluateVisitor(const Context& ctx) : context_(ctx) {} int getResult() { return valueStack_.top(); } void visit(const NumberExpression& expr) override { valueStack_.push(expr.interpret(context_)); } void visit(const AddExpression& expr) override { // 当访问到AddExpression时，栈顶两个元素就是左右操作数的结果 int right = valueStack_.top(); valueStack_.pop(); int left = valueStack_.top(); valueStack_.pop(); valueStack_.push(left + right); } // ... 实现其他visit方法 };

使用访问者模式后，求值逻辑被剥离到了EvaluateVisitor中。如果我们想新增一个“打印表达式树”的功能，只需要再实现一个PrintVisitor，而无需修改任何表达式类。这极大地增强了系统的扩展性。

6.3 性能考量与优化策略

对于频繁解释的表达式，性能可能成为瓶颈。以下是一些优化思路：

1. 预编译/缓存：如果同一个表达式需要被反复解释（例如，一个在循环中使用的业务规则），可以在第一次解释时进行“预编译”。这可以是将语法树转换为另一种更高效的内部表示（如字节码），或者甚至进行简单的常量折叠优化（在解析阶段就计算3 + 5这样的常量子表达式，将其替换为NumberExpression(8)）。
2. Flyweight 模式共享终结符：对于大量重复的终结符（如相同的数字、变量名），可以使用享元模式来共享对象，减少内存占用。例如，所有值为1的NumberExpression可以共享同一个实例。
3. 避免深层递归：对于极度深层的嵌套表达式，递归解释可能导致栈溢出。可以考虑使用显式栈（Stack）来模拟递归过程，将递归算法转化为迭代算法，但这会大大增加代码复杂度。
4. JIT 编译：在极端追求性能的场景下，可以考虑在运行时将表达式树编译成本地机器码。但这已经远远超出了经典解释器模式的范畴，属于高级编译技术。

对于大多数应用级场景，基础的递归解释器性能已经足够。优化前，务必先进行性能剖析，找到真正的热点。

7. 在C++项目中的工程化实践建议

将解释器模式应用到真实的C++项目中，还需要考虑一些工程实践问题。

7.1 项目结构与构建系统

一个清晰的项目结构有助于维护。建议按如下方式组织：

interpreter_project/ ├── CMakeLists.txt ├── include/ │ ├── ast/ # 抽象语法树节点类头文件 │ │ ├── Expression.h │ │ ├── NumberExpression.h │ │ ├── BinaryExpression.h │ │ ├── AddExpression.h │ │ └── ... │ ├── parser/ # 词法、语法分析器头文件 │ │ ├── Lexer.h │ │ └── Parser.h │ └── util/ │ └── Context.h └── src/ ├── ast/ # 表达式类的实现（如果实现不全是头文件） ├── parser/ └── main.cpp

使用现代构建系统如 CMake 来管理编译和依赖。

7.2 内存管理策略选择

我们使用了std::shared_ptr，这是安全且省心的选择。但在性能敏感的场合，需要权衡：

• std::unique_ptr：所有权更清晰，性能略优于shared_ptr。但构建语法树时，所有权的转移需要仔细设计。
• 自定义内存池：如果表达式节点需要被频繁创建和销毁（例如，在解析大量动态生成的表达式时），可以使用对象池来分配固定大小的节点对象，显著减少new/delete的开销。
• 节点不可变性与共享：将表达式节点设计为不可变（Immutable）对象。一旦创建，其值和子节点都不再改变。这使得节点可以被安全地共享（例如，在不同的语法树中复用相同的子表达式），也为缓存优化提供了可能。

7.3 测试策略

解释器模式的测试应分层进行：

1. 单元测试：针对每个具体的表达式类（如AddExpression,NumberExpression）编写测试，验证其interpret方法的正确性。
2. 集成测试：测试Parser和Lexer，给定输入字符串，验证其能否生成正确的语法树。可以通过比较解释结果与预期值来进行。
3. 端到端测试：提供一系列复杂的表达式字符串，测试整个解释器流水线（Lexer -> Parser -> Interpretation）的输出。
4. 模糊测试：生成随机但符合文法的表达式字符串，喂给解释器，检查是否崩溃或产生非法结果（如除零），以提高鲁棒性。

7.4 与现有C++生态的集成

• 使用std::variant或继承：对于表达式类型，我们使用了传统的继承体系。C++17 的std::variant提供了另一种选择，可以将所有表达式类型定义为一个variant，配合std::visit进行访问。这种方式有时能提供更好的局部性和编译期优化，但可能会牺牲一些扩展性。
• 使用现有解析库：对于复杂的文法，强烈建议不要重复造轮子。可以考虑集成像Boost.Spirit（一个C++的递归下降解析器生成库）或ANTLR（生成C++目标代码）这样的成熟工具来生成词法分析器和语法分析器。你只需要专注于定义文法规则和编写语义动作（构建你的表达式AST节点），它们会帮你处理繁琐的解析细节，并能生成效率更高、更健壮的解析代码。

解释器模式是一个深刻体现了“组合优于继承”和“分而治之”思想的设计模式。它将一个复杂的问题（解释一种语言）分解为一系列简单的类（语法规则），并通过对象的递归组合来解决。在C++中，借助其强大的类型系统和多态机制，我们可以构建出类型安全、结构清晰的解释器。虽然对于复杂语言，专门的解析器生成工具是更优解，但对于实现领域特定语言、规则引擎或配置解析器等场景，手写一个基于解释器模式的小型解释器，仍然是极具威力和教育意义的解决方案。理解其精髓，你就能在合适的场景下，优雅地驾驭“语言”的力量。