C++解释器模式实现简单语言解析器

P粉602998670

发布时间：2025-09-12 09:24:01

217人浏览过

来源于php中文网

原创

解释器模式通过将语法规则映射为类，实现语言解析器的可扩展性与直观性，核心组件包括抽象表达式、终结符、非终结符和上下文，支持递归解释执行；其优势在于易于扩展和维护，适合简单DSL，但类数量随语法复杂度增长，性能较低，不适用于高性能场景。

c++解释器模式实现简单语言解析器

C++解释器模式在构建简单语言解析器时，本质上是将语言的每个语法规则映射到一个类结构，从而允许我们用面向对象的方式来表示和解释这些规则。这就像是为我们的迷你语言创建了一个微型的“大脑”，它知道如何理解并执行每个指令，让语言本身变得可执行。在我看来，这种模式的魅力在于它的扩展性和直观性，你几乎可以“看到”语法树在代码中生长。

解决方案

要用C++解释器模式实现一个简单的语言解析器，我们通常会围绕几个核心组件来构建：抽象表达式（AbstractExpression）、终结符表达式（TerminalExpression）、非终结符表达式（NonterminalExpression）和上下文（Context）。

首先，我们需要定义一个抽象基类

AbstractExpression

，它声明一个

interpret

方法，这是所有表达式都需要实现的操作。这个方法会接收一个

Context

对象作为参数，

Context

负责存储解释器运行时的状态，比如变量的值。

接着，我们会为语言中的每一个终结符（比如数字、变量名、布尔值）创建一个

TerminalExpression

子类。这些类在

interpret

方法中会直接处理它们代表的值。例如，一个

NumberExpression

会直接返回它存储的数值，而

VariableExpression

则会从

Context

中查找并返回对应变量的值。

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

然后，对于语言中的非终结符（比如加法、减法、赋值、条件语句），我们创建

NonterminalExpression

子类。这些类通常会包含其他

AbstractExpression

对象的引用，形成一个树形结构。它们的

interpret

方法会递归地调用其子表达式的

interpret

方法，然后根据自身的逻辑对结果进行组合或操作。例如，一个

AddExpression

会调用其左右子表达式的

interpret

方法，然后将结果相加。

最后，

Context

类至关重要。它通常包含一个符号表（比如

std::map

），用于存储变量名和它们对应的值。当解析器执行赋值操作或引用变量时，都会通过

Context

来进行读写。

整个解析过程大致分为两步：

词法分析与语法分析（构建抽象语法树 AST）：将输入的原始代码字符串分解成一个个有意义的Token（词法分析），然后根据语言的语法规则，将这些Token组织成一个抽象语法树（AST）。这一步通常不会直接使用解释器模式的类，而是使用其他解析技术（如递归下降、LL/LR解析器生成器）来完成。AST的每个节点最终会对应一个
```
AbstractExpression
```
对象。
解释执行：一旦AST构建完成，我们就可以调用根表达式节点的
```
interpret
```
方法，它会递归地遍历整个树，最终计算出表达式的值或执行相应的语句。

以一个简单的算术表达式语言为例：

Expression ::= Term | Expression '+' Term | Expression '-' Term

Term ::= Factor | Term '*' Factor | Term '/' Factor

Factor ::= Number | Identifier | '(' Expression ')'

我们可以有

NumberExpression

(Terminal),

VariableExpression

(Terminal),

AddExpression

(Nonterminal),

SubtractExpression

(Nonterminal),

MultiplyExpression

(Nonterminal),

DivideExpression

(Nonterminal) 等等。

#include 
#include 
#include 
#include 
#include  // For std::unique_ptr

// 前置声明
class Context;

// 抽象表达式
class AbstractExpression {
public:
    virtual int interpret(Context& context) = 0;
    virtual ~AbstractExpression() = default;
};

// 上下文：存储变量等运行时信息
class Context {
public:
    std::map variables;

    void assign(const std::string& varName, int value) {
        variables[varName] = value;
    }

    int lookup(const std::string& varName) const {
        auto it = variables.find(varName);
        if (it != variables.end()) {
            return it->second;
        }
        throw std::runtime_error("Undefined variable: " + varName);
    }
};

// 终结符表达式：数字
class NumberExpression : public AbstractExpression {
    int number;
public:
    NumberExpression(int num) : number(num) {}
    int interpret(Context& context) override {
        return number;
    }
};

// 终结符表达式：变量
class VariableExpression : public AbstractExpression {
    std::string name;
public:
    VariableExpression(const std::string& varName) : name(varName) {}
    int interpret(Context& context) override {
        return context.lookup(name);
    }
    const std::string& getName() const { return name; } // 用于赋值操作
};

// 非终结符表达式：加法
class AddExpression : public AbstractExpression {
    std::unique_ptr left;
    std::unique_ptr right;
public:
    AddExpression(std::unique_ptr l, std::unique_ptr r)
        : left(std::move(l)), right(std::move(r)) {}
    int interpret(Context& context) override {
        return left->interpret(context) + right->interpret(context);
    }
};

// 非终结符表达式：减法
class SubtractExpression : public AbstractExpression {
    std::unique_ptr left;
    std::unique_ptr right;
public:
    SubtractExpression(std::unique_ptr l, std::unique_ptr r)
        : left(std::move(l)), right(std::move(r)) {}
    int interpret(Context& context) override {
        return left->interpret(context) - right->interpret(context);
    }
};

// 非终结符表达式：赋值
class AssignmentExpression : public AbstractExpression {
    std::unique_ptr var;
    std::unique_ptr expr;
public:
    AssignmentExpression(std::unique_ptr v, std::unique_ptr e)
        : var(std::move(v)), expr(std::move(e)) {}
    int interpret(Context& context) override {
        int value = expr->interpret(context);
        context.assign(var->getName(), value);
        return value;
    }
};

// 客户端代码示例（构建AST并解释）
/*
int main() {
    Context context;

    // 构建表达式：a = 10
    // std::unique_ptr assign_a =
    //     std::make_unique(
    //         std::make_unique("a"),
    //         std::make_unique(10)
    //     );
    // assign_a->interpret(context); // 执行赋值

    // 构建表达式：b = 5
    // std::unique_ptr assign_b =
    //     std::make_unique(
    //         std::make_unique("b"),
    //         std::make_unique(5)
    //     );
    // assign_b->interpret(context); // 执行赋值

    // 构建表达式：a + b
    // std::unique_ptr expression =
    //     std::make_unique(
    //         std::make_unique("a"),
    //         std::make_unique("b")
    //     );

    // int result = expression->interpret(context);
    // std::cout << "Result: " << result << std::endl; // 应该输出 15

    return 0;
}
*/

上述代码片段展示了核心的类结构，但缺少了从字符串到AST的构建过程。在实际应用中，你需要一个解析器（parser）来读取输入字符串，并根据语法规则创建这些

Expression

对象，组装成AST。

解释器模式在构建语言解析器时有哪些核心优势和局限性？

在我看来，解释器模式在构建语言解析器时，最直观的优势在于它的可扩展性。当你的语言需要增加新的语法规则或操作时，你通常只需要添加新的

TerminalExpression

或

NonterminalExpression

类，而无需修改现有的大部分代码。这种“即插即用”的特性对于那些需要频繁演进的小型领域特定语言（DSL）来说，简直是福音。每个语法规则都对应一个类，使得语法表示非常清晰，代码结构与语言本身的结构高度吻合，这对于代码的理解和维护都非常有帮助。此外，它还能够解耦语法规则和解释执行的逻辑，让各自的职责更加明确。

极品模板多语言企业网站管理系统1.2.2

【极品模板】出品的一款功能强大、安全性高、调用简单、扩展灵活的响应式多语言企业网站管理系统。产品主要功能如下： 01、支持多语言扩展（独立内容表，可一键复制中文版数据） 02、支持一键修改后台路径； 03、杜绝常见弱口令，内置多种参数过滤、有效防范常见XSS； 04、支持文件分片上传功能，实现大文件轻松上传； 05、支持一键获取微信公众号文章（保存文章的图片到本地服务器）； 06、支持一键

下载

然而，凡事都有两面性。解释器模式的局限性也同样明显。对于复杂的语法，表达式类的数量会呈爆炸式增长，维护起来会变得非常困难，甚至让人望而却步。想象一下，如果你的语言包含几十种操作符、复杂的控制流和数据结构，那么对应的类文件可能会多到让你头晕。此外，由于其高度的面向对象特性和递归调用，解释器模式在性能上可能不如直接编译或更优化的解析器。每次解释都需要遍历AST，这在处理大量或高性能要求的代码时可能会成为瓶颈。坦白说，如果你的目标是构建一个高性能的通用编程语言解析器，解释器模式可能不是首选，它更适合那些语法相对简单、需要高扩展性的场景。

如何为C++简单语言解析器设计一个有效的语法结构？

设计一个有效的语法结构是构建任何语言解析器的基石，C++解释器模式也不例外。在我看来，最开始的一步，也是最重要的一步，是明确你的语言能做什么，它的核心功能是什么。你希望它能处理算术运算？变量赋值？条件判断？还是循环？一旦这些核心功能确定了，就可以着手定义形式化的语法规则了。

我个人比较喜欢从BNF（巴科斯范式）或EBNF（扩展巴科斯范式）开始。这两种形式能清晰地描述语言的句法结构。例如，一个极简的算术和赋值语言可能包含以下规则：

// 语句：可以是赋值，也可以是表达式
Statement ::= Assignment | Expression

// 赋值：变量名 = 表达式
Assignment ::= Identifier '=' Expression

// 表达式：可以是一个项，也可以是项之间通过加减连接
Expression ::= Term (('+' | '-') Term)*

// 项：可以是一个因子，也可以是因子之间通过乘除连接
Term ::= Factor (('*' | '/') Factor)*

// 因子：可以是数字、变量名，或者括号括起来的表达式
Factor ::= Number | Identifier | '(' Expression ')'

// 终结符定义
Number ::= [0-9]+
Identifier ::= [a-zA-Z_][a-zA-Z0-9_]*

这里需要注意几个关键点：

操作符优先级：比如乘除的优先级高于加减。在BNF中，这通常通过不同的非终结符（如
```
Term
```
和
```
Factor
```
）来体现，越底层的规则优先级越高。
操作符结合性：例如，加法和减法是左结合的（
```
a - b - c
```
应该解释为
```
(a - b) - c
```
）。这在BNF中通常通过左递归规则来表示，如
```
Expression ::= Expression '+' Term
```
。
终结符和非终结符的区分：终结符是语言中最基本的符号（如数字、操作符、关键字），它们不能再被分解。非终结符则代表了更复杂的语法结构。

一旦有了这样的语法定义，将其映射到解释器模式的类结构就变得相对直接了。每个非终结符通常对应一个

NonterminalExpression

类，每个终结符则对应一个

TerminalExpression

类。例如，

AddExpression

会包含两个

AbstractExpression

成员（分别代表左操作数和右操作数），而

NumberExpression

则只包含一个整数值。这个过程会自然而然地引导你构建出抽象语法树的结构。

在C++中实现解释器模式时，如何处理上下文和变量作用域？

在C++中实现解释器模式时，

Context

类是处理运行时状态，尤其是变量作用域的核心。我个人觉得，一个设计良好的

Context

不仅能存储变量值，还能优雅地处理作用域嵌套，这对于任何稍微复杂一点的语言都是必不可少的。

对于最简单的语言，比如只有全局变量的算术表达式，

Context

类可能只需要一个

std::map

（或者如果你需要浮点数或更复杂的值，可以使用

std::map

）来存储变量名和它们对应的值。

interpret

方法在遇到

VariableExpression

时，就从这个

map

中查找；遇到

AssignmentExpression

时，就更新这个

map

。

// 简单的全局上下文示例
class Context {
public:
    std::map variables;

    void assign(const std::string& varName, int value) {
        variables[varName] = value;
        // std::cout << "Assigned " << varName << " = " << value << std::endl; // 调试输出
    }

    int lookup(const std::string& varName) const {
        auto it = variables.find(varName);
        if (it != variables.end()) {
            return it->second;
        }
        // 在实际应用中，这里应该抛出更具体的错误或返回一个默认值
        throw std::runtime_error("Runtime Error: Undefined variable '" + varName + "'");
    }
};

然而，如果你的语言支持函数、代码块（如

if

语句或

for

循环内部的

{}

），那么就需要处理作用域嵌套。一个常见的做法是让

Context

维护一个符号表栈。每次进入一个新的作用域（比如函数调用或代码块），就向栈中压入一个新的

map

来代表当前作用域的局部变量。查找变量时，从栈顶开始向下查找，直到找到变量或者栈底。退出作用域时，就从栈中弹出对应的

map

。

// 支持作用域的上下文示例
class Context {
public:
    // 栈中的每个map代表一个作用域
    std::vector> scopes;

    Context() {
        scopes.push_back({}); // 初始时有一个全局作用域
    }

    void enterScope() {
        scopes.push_back({}); // 压入新的局部作用域
        // std::cout << "Entered new scope. Total scopes: " << scopes.size() << std::endl;
    }

    void exitScope() {
        if (scopes.size() > 1) { // 至少保留一个全局作用域
            scopes.pop_back();
            // std::cout << "Exited scope. Total scopes: " << scopes.size() << std::endl;
        } else {
            throw std::runtime_error("Cannot exit global scope.");
        }
    }

    void assign(const std::string& varName, int value) {
        // 优先在当前作用域（栈顶）赋值
        if (!scopes.empty()) {
            scopes.back()[varName] = value;
        } else {
            throw std::runtime_error("No active scope to assign variable.");
        }
    }

    int lookup(const std::string& varName) const {
        // 从当前作用域开始，向上查找
        for (auto it = scopes.rbegin(); it != scopes.rend(); ++it) {
            auto var_it = it->find(varName);
            if (var_it != it->end()) {
                return var_it->second;
            }
        }
        throw std::runtime_error("Runtime Error: Undefined variable '" + varName + "'");
    }
};

// 假设我们有一个BlockExpression，它会管理作用域
/*
class BlockExpression : public AbstractExpression {
    std::vector> statements;
public:
    BlockExpression(std::vector> s)
        : statements(std::move(s)) {}
    int interpret(Context& context) override {
        context.enterScope(); // 进入新的作用域
        int last_result = 0;
        for (const auto& stmt : statements) {
            last_result = stmt->interpret(context); // 执行语句
        }
        context.exitScope(); // 退出作用域
        return last_result;
    }
};
*/

这种栈式的