领域模式_Interpreter

作者出版于 design_patterns

2023-07-15 约 747 字预计阅读 2 分钟

领域模式

在特定领域中，某些变化虽然频繁，但可以抽象为某种规则。这时候，结合特定领域，将问题抽象为语法规则，从而给出在该领域下的一般性解决方案。

典型模式

Interpreter

1 Interpreter

1.1 模式动机

在软件构建过程中，如果某一特定领域的问题比较复杂，类似的结构不断重复出现，如果使用普通的编程方式来实现将面临非常频繁的变化。

在这种情况下，将特定领域的问题表达为某种语法规则下的句子，然后构建一个解释器来解释这样的句子，从而达到解决问题的目的。

1.2 模式定义

给定一个语言，定义它的文法的一种表示，并定义一种解释器，这个解释器使用该表示来解释语言中的句子。

1.3 模式示例代码

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

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

// 终结符表达式类：数字表达式
class NumberExpression : public Expression {
public:
    NumberExpression(int number) : number(number) {}

    int interpret() {
        return number;
    }

private:
    int number;
};

// 非终结符表达式类：加法表达式
class AddExpression : public Expression {
public:
    AddExpression(Expression* left, Expression* right) : left(left), right(right) {}

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

private:
    Expression* left;
    Expression* right;
};

// 非终结符表达式类：减法表达式
class SubtractExpression : public Expression {
public:
    SubtractExpression(Expression* left, Expression* right) : left(left), right(right) {}

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

private:
    Expression* left;
    Expression* right;
};

// 解析器类：解析器
class Parser {
public:
    Expression* parse(const std::string& expression) {
        std::stack<Expression*> stack;
        for (int i = 0; i < expression.length(); ++i) {
            if (isdigit(expression[i])) {
                int number = expression[i] - '0';
                stack.push(new NumberExpression(number));
            } else if (expression[i] == '+') {
                Expression* right = stack.top();
                stack.pop();
                Expression* left = stack.top();
                stack.pop();
                stack.push(new AddExpression(left, right));
            } else if (expression[i] == '-') {
                Expression* right = stack.top();
                stack.pop();
                Expression* left = stack.top();
                stack.pop();
                stack.push(new SubtractExpression(left, right));
            }
        }
        return stack.top();
    }
};

int main() {
    Parser parser;

    // 解析并计算数学表达式："5 + (7 - 3)"
    Expression* expression = parser.parse("5+(7-3)");
    int result = expression->interpret();
    std::cout << "计算结果：" << result << std::endl;

    // 释放内存（可选）
    delete expression;

    return 0;
}

2 要点总结

Interpreter 模式的应用场合是 Interpreter 模式应用中的难点，只有满足“业务规则频繁变化，且类似的结构不断重复出现，并且容易抽象为语法规则的问题“才适合使用 Interpreter 模式。

使用 Interpreter 模式来表示文法规则，从而可以使用面向对象技巧来方便地“扩展“文法。

Interpreter 模式比较适合简单的文法表示，对于复杂的文法表示， Interperter 模式会产生比较大的类层次结构，需要求助于语法分析生成器这样的标准工具。

目录