【C++设计模式之解释器模式:行为型】分析及示例

news2024/11/15 20:02:05

简介

解释器模式（Interpreter Pattern）是一种行为型设计模式，它提供了一种解决问题的方法，通过定义语言的文法规则，解释并执行特定的语言表达式。
解释器模式通过使用表达式和解释器，将文法规则中的句子逐个解释执行。它将一些复杂的业务逻辑分解为一系列的简单表达式，通过解析和执行这些表达式来实现业务逻辑的处理。

描述

解释器模式通常用于处理某种特定领域的语言或规则。它将待解析的句子转换为抽象语法树，并按照语法规则逐个解析节点。每个节点都可以表示一个终结符或非终结符，并提供相应的解释方法。

原理

解释器模式的核心原理是将句子解析成为抽象语法树，然后通过遍历和解释节点来执行语义操作。解释器模式通常包含以下角色：

抽象表达式（Abstract Expression）：定义了解释器的抽象接口，包含解释方法 interpret()。
终结符表达式（Terminal Expression）：表示句子中的终结符（如变量、常量等），实现了解释方法 interpret()。
非终结符表达式（Nonterminal Expression）：表示句子中的非终结符（如加法、减法等运算），定义了解释方法 interpret()。

类图

在这里插入图片描述

Context：环境角色（上下文），含有每个解释器所需的一些数据或全局的一些信息。
AbstractExpression：抽象表达式类，声明了抽象的解释操作，所有解释器类都继承或实现该类。
TerminalExpression：终结符表达式类，是AbstractExpression的子类，实现了文法中有关终结符相关的解释操作。
NonTerminalExpression：非终结符表达式，AbstractExpression的子类，该类的功能与终结表达式类相反，文法中所有非终结符由该类进行解释。
Client：客户端测试类。

示例

假设我们需要实现一个简单的数学表达式解析器，可以计算表达式的值。表达式可以包含整数、加法和减法操作。

在下面的示例中，我们定义了抽象表达式类 Expression 和具体的终结符表达式类 IntegerExpression，以及具体的非终结符表达式类 AddExpression 和 SubtractExpression。程序通过解析句子中的各个表达式，并执行相应的操作。

#include <iostream>
#include <string>
#include <stack>

// 抽象表达式类
class Expression {
public:
    virtual int interpret() 0;
};

// 终结符表达式类
class IntegerExpression : public Expression {
private:
    int value;

public:
    IntegerExpression(int value) : value(value) {}

    int interpret() {
        return value;
    }
};

// 非终结符表达式类
class AddExpression : public Expression {
private:
    Expression* left;
    Expression* right;

public:
    AddExpression(Expression* left, Expression* right)
        : left(left), right(right) {}

 int interpret() {
        return left->interpret() + right->interpret();
    }
};

class Subtract : public Expression {
private
	Expression* left;
    Expression* right;

public:
    SubtractExpression(Expression* left, Expression* right)
        : left(left), right(right) {}

    int interpret() {
        return left->interpret() - right->interpret();
    }
};

// 解析器
class Parser {
public:
 static Expression* parse(const std::string& input) {
        std::stack<Expression*> expressionStack;

        int pos = 0;
        while (pos < input.size()) {
            if (isdigit(input[pos])) {
                int value = 0;
                while (pos < input.size() && isdigit(input[pos])) {
                    value = value * 10 + (input[pos] - 0);
                    pos++;
                }
               expressionStack.push(new IntegerExpression(value));
            } else if (input[pos] == '+') {
                Expression* right = expressionStack.top();
                expressionStack.pop();
                Expression* left = expressionStack.top();
                expressionStack.pop();

                expressionStack.push(new AddExpression(left, right));
                pos++;
            } else if (input[pos] == '-') {
                Expression* right = expressionStack.top();
                expressionStack.pop();
                Expression* left = expressionStack.top();
                expressionStack.pop();

                expressionStack.push(new SubtractExpression(left, right));
                pos++;
            } else {
                pos++;
            }
        }

        return expressionStack.top();
    }
};

int main() {
    std::string input = "5+2-1";
    Expression* expression = Parser::parse(input);
    int result = expression->interpret();
    std::cout << "Result: " << result << std::endl;

    delete expression;

    return 0;
}