解释器模式通过定义文法并构建抽象语法树来解释语言中的句子。在C++中，以算术表达式为例，Expression为抽象基类，NumberExpression作为终结符表达式表示常量，AddExpression和MultiplyExpression作为非终结符表达式实现加乘逻辑，Context可存储变量信息，客户端手动构建AST并调用interpret方法计算结果，如3 + 5 * 2返回13；实际应用中建议使用智能指针管理内存，并可扩展支持变量与符号表，适用于DSL解析等场景，但复杂文法下类膨胀且性能较低。

解释器模式（Interpreter Pattern）是一种行为设计模式，用于定义语言的文法，并通过一个解释器来解释该语言中的句子。在C++中实现解释器模式，通常用于处理简单的领域特定语言（DSL）、表达式计算、配置解析等场景。

解释器模式的基本结构

解释器模式的核心思想是将语言中的每个语法规则映射为一个类，通过组合这些类构建抽象语法树（AST），然后通过递归调用解释方法来执行语义逻辑。

主要角色包括：

• AbstractExpression：抽象表达式，声明一个解释操作 interpret。
• TerminalExpression：终结符表达式，代表文法中的最小单位，如变量、常量。
• NonTerminalExpression：非终结符表达式，表示文法中的组合规则，如加减乘除操作。
• Context：上下文环境，包含解释器需要的数据或全局状态。
• Client：构建抽象语法树并调用解释器。

用C++实现一个算术表达式解释器

我们以一个简单的四则运算表达式为例，比如 "3 + 5 * 2"，展示如何使用解释器模式进行解析和计算。

立即学习“C++免费学习笔记（深入）”；

注意：本例不涉及词法分析和语法分析器生成，仅手动构建AST来演示模式本身。

首先定义抽象表达式基类：

Expression.h

#ifndef EXPRESSION_H
#define EXPRESSION_H
class Context {
public:
// 可用于存储变量值等信息
};
class Expression {
public:
virtual ~Expression() = default;
virtual int interpret() const = 0;
};
endif

实现常量表达式（终结符）：

NumberExpression.h/cpp

#include "Expression.h"
class NumberExpression : public Expression {
int value;
public:
NumberExpression(int val) : value(val) {}
int interpret() const override {
return value;
}
};

实现加法和乘法表达式（非终结符）：

AddExpression.h/cpp

#include "Expression.h"
class AddExpression : public Expression {
Expression left;
Expression right;
public:
AddExpression(Expression l, Expression r) : left(l), right(r) {}
int interpret() const override {
return left->interpret() + right->interpret();
}
};

MultiplyExpression.h/cpp

#include "Expression.h"
class MultiplyExpression : public Expression {
Expression left;
Expression right;
public:
MultiplyExpression(Expression l, Expression r) : left(l), right(r) {}
int interpret() const override {
return left->interpret() * right->interpret();
}
};

客户端使用示例：

main.cpp

#include 
#include "NumberExpression.h"
#include "AddExpression.h"
#include "MultiplyExpression.h"
int main() {
// 构建表达式树：3 + (5  2)
Expression five = new NumberExpression(5);
Expression two = new NumberExpression(2);
Expression three = new NumberExpression(3);
Expression* mul = new MultiplyExpression(five, two); // 5 * 2
Expression* add = new AddExpression(three, mul);     // 3 + (5 * 2)

std::cout << "Result: " << add->interpret() << std::endl; // 输出 13

// 清理内存（实际项目建议使用智能指针）
delete five;
delete two;
delete three;
delete mul;
delete add;

return 0;
}

优化与注意事项
上述实现是解释器模式的基础版本。在实际工程中，还需考虑以下几点：

使用 std::unique_ptr 管理内存，避免泄漏。
支持变量表达式，例如引入符号表到 Context 中。
结合词法分析器（Lexer）和递归下降解析器（Parser）自动构建AST。
对复杂语言，解释器模式可能性能较低，可考虑编译成字节码或转换为函数对象。

例如，添加变量支持：
class Context {
    std::map 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);
        return it != variables.end() ? it->second : 0;
    }
};
class VariableExpression : public Expression {
std::string name;
public:
VariableExpression(const std::string& varName) : name(varName) {}
int interpret(Context& ctx) const override {
return ctx.getVariable(name);
}
};
适用场景与局限性
解释器模式适用于：

有简单文法且频繁使用的语言。
需要可扩展语法解释能力的系统。
DSL（领域特定语言）的实现。

但它也有缺点：

复杂文法会导致类数量激增。
调试困难，AST结构不易可视化。
性能不如编译型方案。

基本上就这些。解释器模式提供了一种优雅的方式来建模语言结构，虽然不常用于高性能场景，但在配置脚本、规则引擎中仍有实用价值。