C++实现设计模式---解释器模式 (Interpreter Pattern)

解释器模式 (Interpreter Pattern)

解释器模式 是一种行为型设计模式，它提供了一个语言的语法表示，并定义了一个解释器来处理这个语言的语法。通过解释器模式，可以实现对特定语法或表达式的解析和执行。

意图

定义一种语言的文法，并提供一个解释器来处理语言中的语句。
通过解析和解释特定语言的表达式，实现灵活的扩展和动态计算。

使用场景

需要解析特定语法或表达式：
- 如计算器的表达式求值。
语言规则相对简单，且可扩展：
- 规则可以使用组合模式表达。
需要对用户输入的语句进行解析并执行：
- 如脚本语言解析器。

参与者角色

抽象表达式 (Expression)
- 定义解释操作的接口。
终结符表达式 (TerminalExpression)
- 实现与文法中的终结符相关的解释操作。
非终结符表达式 (NonTerminalExpression)
- 实现文法中的非终结符的解释操作，通常是其他表达式的组合。
上下文 (Context)
- 包含解释器需要的全局信息。
客户端 (Client)
- 构建文法树，并通过调用解释器来解释表达式。

示例代码

以下代码展示了解释器模式的实现，用于解析和计算简单的数学表达式。

#include <iostream>
#include <string>
#include <memory>
#include <unordered_map>// 抽象表达式
class Expression {
public:virtual ~Expression() = default;// 解释方法virtual int interpret(const std::unordered_map<std::string, int>& context) const = 0;
};// 终结符表达式：变量
class VariableExpression : public Expression {
private:std::string name;public:explicit VariableExpression(std::string name) : name(std::move(name)) {}int interpret(const std::unordered_map<std::string, int>& context) const override {auto it = context.find(name);if (it != context.end()) {return it->second; // 返回变量的值}throw std::runtime_error("变量未定义: " + name);}
};// 终结符表达式：常量
class ConstantExpression : public Expression {
private:int value;public:explicit ConstantExpression(int value) : value(value) {}int interpret(const std::unordered_map<std::string, int>& context) const override {return value; // 返回常量值}
};// 非终结符表达式：加法
class AddExpression : public Expression {
private:std::shared_ptr<Expression> left;std::shared_ptr<Expression> right;public:AddExpression(std::shared_ptr<Expression> left, std::shared_ptr<Expression> right): left(std::move(left)), right(std::move(right)) {}int interpret(const std::unordered_map<std::string, int>& context) const override {return left->interpret(context) + right->interpret(context); // 加法操作}
};// 非终结符表达式：减法
class SubtractExpression : public Expression {
private:std::shared_ptr<Expression> left;std::shared_ptr<Expression> right;public:SubtractExpression(std::shared_ptr<Expression> left, std::shared_ptr<Expression> right): left(std::move(left)), right(std::move(right)) {}int interpret(const std::unordered_map<std::string, int>& context) const override {return left->interpret(context) - right->interpret(context); // 减法操作}
};// 客户端代码
int main() {// 构建表达式: (x + 10) - yauto x = std::make_shared<VariableExpression>("x");auto y = std::make_shared<VariableExpression>("y");auto constant = std::make_shared<ConstantExpression>(10);auto addExpr = std::make_shared<AddExpression>(x, constant); // x + 10auto subtractExpr = std::make_shared<SubtractExpression>(addExpr, y); // (x + 10) - y// 上下文std::unordered_map<std::string, int> context = {{"x", 5}, {"y", 3}};// 解释表达式std::cout << "表达式结果: " << subtractExpr->interpret(context) << "
"; // 输出结果: 12return 0;
}

代码解析

1. 抽象表达式 (Expression)

定义了解释操作的接口，所有具体表达式类都需要实现此接口。

class Expression {
public:virtual ~Expression() = default;virtual int interpret(const std::unordered_map<std::string, int>& context) const = 0;
};

2. 终结符表达式

VariableExpression：表示变量，解释时从上下文中获取变量的值。
ConstantExpression：表示常量，解释时直接返回常量值。

class VariableExpression : public Expression {int interpret(const std::unordered_map<std::string, int>& context) const override {return context.at(name);}
};

3. 非终结符表达式

AddExpression 和 SubtractExpression 实现了抽象表达式接口。
它们通过组合其他表达式实现复杂的语法结构。

class AddExpression : public Expression {int interpret(const std::unordered_map<std::string, int>& context) const override {return left->interpret(context) + right->interpret(context);}
};