C++解释器模式

解释器模式

解释器模式是一种行为设计模式，它定义了一种语言文法的表示，并提供了解释器来解释这个语言中的句子。解释器模式可以用于解决特定问题中的解释和执行问题，通常用于处理复杂的语法或规则。

使用场景：

1、当需要解释和执行特定语法规则或表达式时，可以考虑使用解释器模式。
2、当系统中存在大量的重复的规则或表达式，并且这些规则或表达式可以被解释为特定的语言时，解释器模式也是一个不错的选择。

优势：

1、可以灵活地扩展语法规则，增加新的解释器类来支持新的语法规则。
2、可以将语法规则和解释器分离，使得系统更加易于维护和扩展。

劣势：

1、可能会导致类的数量增加，使得系统变得复杂。
2、对于复杂的语法规则，可能需要设计大量的解释器类，增加了系统的复杂度。

Code

#include <iostream>
#include <unordered_map>
#include <string>

class Context {
private:
    std::unordered_map<std::string, int> variables;

public:
    void setVariable(const std::string& name, int value) {
        variables[name] = value;
    }

    int getVariable(const std::string& name) {
        return variables[name];
    }
};

class AbstractExpression {
public:
    virtual int interpret(Context& context) = 0;
};

class TerminalExpression : public AbstractExpression {
private:
    std::string variableName;

public:
    TerminalExpression(const std::string& variable) : variableName(variable) {}

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

class NonterminalExpression : public AbstractExpression {
private:
    AbstractExpression* expression1;
    AbstractExpression* expression2;

public:
    NonterminalExpression(AbstractExpression* expr1, AbstractExpression* expr2)
        : expression1(expr1), expression2(expr2) {}

    int interpret(Context& context) override {
        return expression1->interpret(context) + expression2->interpret(context);
    }
};

int main() {
    Context context;
    context.setVariable("a", 5);
    context.setVariable("b", 10);

    AbstractExpression* expr1 = new TerminalExpression("a");
    AbstractExpression* expr2 = new TerminalExpression("b");
    AbstractExpression* expr3 = new NonterminalExpression(expr1, expr2);

    int result = expr3->interpret(context);
    std::cout << "Result: " << result << std::endl;

    delete expr1;
    delete expr2;
    delete expr3;

    while (1);
    return 0;
}