设计模式（13）-解释器模式及实现

设计模式（13）-解释器模式及实现

---

基本概念

通过定义一种语言文法的表示，并提供一种解释器来解释这种语言的语句。这样，你可以将语句表示为抽象语法树，然后通过解释器逐步执行和解释这个语法树。
优点：
可以使你更容易地实现特定语言的解释和执行，尤其在处理自定义的领域特定语言时非常有用。
缺点：
解释器模式可能导致类的数量增加，因为每个语法规则都需要一个相应的表达式类。此外，解释器模式可能会对性能产生影响，特别是在处理复杂语法时。

https://gitee.com/want-to-lose-another-30-jin/design-pattern-implementation

设计模式具体实现

---

角色

1、抽象表达式（Abstract Expression）：
定义了解释器的接口，规定如何解释文法中的各个元素。
2、终结符表达式（Terminal Expression）：
实现了抽象表达式，用于表示文法中的终结符。终结符是文法中的最小单位，不能再分解。
3、非终结符表达式（Nonterminal Expression）：
也实现了抽象表达式，用于表示文法中的非终结符。非终结符可以进一步分解为更小的终结符或非终结符。
4、上下文（Context）：
包含解释器之外的全局信息，可以为解释器提供解释文法所需的外部数据。

java实现

package shejimoshi.jieshiqimoshi;
// 抽象表达式
public interface Expression {
    boolean interpret(String context);
}

package shejimoshi.jieshiqimoshi;
// 终结符表达式
public class TerminalExpression implements Expression {
    private String data;

    public TerminalExpression(String data) {
        this.data = data;
    }

    @Override
    public boolean interpret(String context) {
        // 根据上下文解释终结符
        return context.equals(data);
    }
}

package shejimoshi.jieshiqimoshi;
// 非终结符表达式
public class OrExpression implements Expression {
    private Expression expr1, expr2;

    public OrExpression(Expression expr1, Expression expr2) {
        this.expr1 = expr1;
        this.expr2 = expr2;
    }

    @Override
    public boolean interpret(String context) {
        // 解释非终结符，可以进一步分解为更小的表达式
        return expr1.interpret(context) || expr2.interpret(context);
    }
}

package shejimoshi.jieshiqimoshi;

public class client {
    public static void main(String[] args) {
        Expression expr1 = new TerminalExpression("terminal");
        Expression expr2 = new TerminalExpression("something else");
        Expression or = new OrExpression(expr1, expr2); // 使用不同的表达式

        System.out.println(or.interpret("terminal")); // true
        System.out.println(or.interpret("something else")); // true
        System.out.println(or.interpret("or")); // false
    }
}

c++实现

#include<iostream>
// 抽象表达式
class Expression {
public:
    virtual ~Expression() {}
    virtual bool interpret(const std::string& context) = 0;
};

// 终结符表达式
class TerminalExpression : public Expression {
private:
    std::string data;

public:
    TerminalExpression(const std::string& data) : data(data) {}

    bool interpret(const std::string& context) override {
        // 根据上下文解释终结符
        return context == data;
    }
};

// 非终结符表达式
class OrExpression : public Expression {
private:
    Expression* expr1, * expr2;

public:
    OrExpression(Expression* expr1, Expression* expr2) : expr1(expr1), expr2(expr2) {}

    ~OrExpression() {
        delete expr1;
        delete expr2;
    }

    bool interpret(const std::string& context) override {
        // 解释非终结符，可以进一步分解为更小的表达式
        return expr1->interpret(context) || expr2->interpret(context);
    }
};

// 客户端
int main() {
    Expression* expr1 = new TerminalExpression("terminal");
    Expression* expr2 = new TerminalExpression("something else");
    Expression* or_val = new OrExpression(expr1,expr2);

    std::cout << (or_val->interpret("terminal") ? "true" : "false") << std::endl; // true
    std::cout << (or_val->interpret("something else") ? "true" : "false") << std::endl; // true
    std::cout << (or_val->interpret("or") ? "true" : "false") << std::endl; // false

    delete or_val;
    return 0;
}