设计模式26-解析器模式

动机
定义与结构
- 定义
- 结构
C++代码推导
- 代码说明
优缺点
应用
总结

动机

在软件构建过程中，如果某一特定领域的问题比较复杂，类似结构会不断重复的出现。如果使用普通的编程方式来实现，将面临非常频繁的变化。
在这种情况下，将特定领域的问题表达为某种语法规则下的句子。然后构建一个解释器来解释这样的句子。从而达到解决问题的目的。
解析器模式（Interpreter Pattern）主要用于设计一个语言的解释器，该语言可能是简单的命令语言、表达式语言、或某种配置语言。动机源于这样一个需求：在某些应用程序中，可能会涉及到对特定领域语言（DSL）的解释或执行。为了避免重复编写这些语言的解释代码，并使代码易于扩展和维护，解析器模式提供了一种可行的解决方案。
解析器模式通过为语言的每一个表达式（或符号）定义一个类来实现解释操作。这些类通过组合来构建复杂的表达式，并且这些表达式可以在运行时被解释和执行。使用解析器模式可以让你轻松地为新的表达式添加支持，而无需修改现有代码。

定义与结构

定义

解析器模式是一种行为设计模式，它定义了一个语言的语法表示，并实现一个解释器来处理该语言的句子。解析器模式将表达式解析为抽象语法树（AST），然后通过遍历语法树来执行或评估表达式。

结构

在这里插入图片描述

这张图片展示了解析器模式（Interpreter Pattern）的类结构。解析器模式是一种行为设计模式，它定义了一个表达式的接口，用来解释一个特定的上下文中的表达式。这种模式被用于构建解释器，这些解释器用于分析字符串、数学表达式或任何其他需要解释的语法。

以下是类图中各部分的详细解释：

Context 类：
- Context 通常是解析过程中的上下文环境。它包含了所有与解释操作相关的全局信息。在图中的类结构中，Context 被错误地描述为 TerminalExpression 和 NonterminalExpression 的基类，这在标准的解析器模式实现中是不常见的。实际上，Context 应该是独立于表达式类型的，用于在解释过程中传递数据。
Expression 接口：
- 虽然图中没有明确显示，但在解析器模式中，通常会有一个 Expression 接口（或抽象类），它定义了 Interpret(Context) 方法。这个方法用于对表达式进行解释，并根据当前上下文环境返回结果。TerminalExpression 和 NonterminalExpression 通常会实现这个接口。
TerminalExpression 类：
- TerminalExpression 是实现了 Expression 接口的类之一，用于表示解析树中的叶子节点。这些节点是表达式的最基本单元，例如字面量值（如数字、字符串等），它们不包含其他表达式。TerminalExpression 类的 Interpret(Context) 方法将直接返回该表达式的结果，而不需要进一步解析。
NonterminalExpression 类：
- NonterminalExpression 也是实现了 Expression 接口的类，但它代表了解析树中的非叶子节点。这些节点通常包含了一个或多个其他表达式（子节点），并定义了如何将这些子表达式的解释结果组合起来形成最终的结果。NonterminalExpression 的 Interpret(Context) 方法会递归地调用其子节点的 Interpret 方法，并根据需要处理这些结果。
Client 类：
- Client 类是解析器模式的使用者，它构建了一个表达式树（由 TerminalExpression 和 NonterminalExpression 实例组成），并通过调用根节点的 Interpret(Context) 方法来启动解释过程。Client 类负责设置解析所需的初始上下文，并处理解释结果。

C++代码推导

以下是一个简单的解析器模式示例，它实现了一个基本的数学表达式解释器，该解释器支持加法和减法操作。

#include <iostream>
#include <string>
#include <map>
#include <memory>

// 上下文类，包含变量的值
class Context {
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;
        }
        return 0; // 默认返回0
    }

private:
    std::map<std::string, int> variables;
};

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

// 终结符表达式类，用于表示变量
class VariableExpression : public Expression {
public:
    VariableExpression(const std::string& name) : name_(name) {}

    int interpret(const Context& context) const override {
        return context.getVariable(name_);
    }

private:
    std::string name_;
};

// 终结符表达式类，用于表示数字常量
class NumberExpression : public Expression {
public:
    NumberExpression(int value) : value_(value) {}

    int interpret(const Context& context) const override {
        return value_;
    }

private:
    int value_;
};

// 非终结符表达式类，用于表示加法
class AddExpression : public Expression {
public:
    AddExpression(std::unique_ptr<Expression> left, std::unique_ptr<Expression> right)
        : left_(std::move(left)), right_(std::move(right)) {}

    int interpret(const Context& context) const override {
        return left_->interpret(context) + right_->interpret(context);
    }

private:
    std::unique_ptr<Expression> left_;
    std::unique_ptr<Expression> right_;
};

// 非终结符表达式类，用于表示减法
class SubtractExpression : public Expression {
public:
    SubtractExpression(std::unique_ptr<Expression> left, std::unique_ptr<Expression> right)
        : left_(std::move(left)), right_(std::move(right)) {}

    int interpret(const Context& context) const override {
        return left_->interpret(context) - right_->interpret(context);
    }

private:
    std::unique_ptr<Expression> left_;
    std::unique_ptr<Expression> right_;
};

int main() {
    Context context;
    context.setVariable("x", 10);
    context.setVariable("y", 20);

    // 表达式 x + y - 5
    auto expression = std::make_unique<SubtractExpression>(
        std::make_unique<AddExpression>(
            std::make_unique<VariableExpression>("x"),
            std::make_unique<VariableExpression>("y")),
        std::make_unique<NumberExpression>(5)
    );

    std::cout << "Result: " << expression->interpret(context) << std::endl; // 输出 25

    return 0;
}