《解释器模式（极简c++）》

        本文章属于专栏- 概述 - 《设计模式（极简c++版）》-CSDN博客

模式说明

• 方案： 对每个data建立一个单点解释器对象X，dataA和dataB之间的关系，建立一个关系解释器对象Y，这里的Y处理的是X1和X2。这样，复用了解释单文本的逻辑，和多文本间关系的逻辑。
• 优点：
  • 灵活性：易于改变和扩展文法，增加新的解释器。
  • 易于实现：将文法规则表示为类的层次结构，每个规则由一个解释器表示，易于理解和实现。
• 缺点：
  • 复杂度：当文法规则复杂时，可能需要大量的解释器类来表示。

本质思想：解释器模式通过将语言的文法表示为类的层次结构，然后建立解释器来解释这些类，从而实现对语言的解释和执行。

实践建议：除了正则表达式，文本相关的解析等特别灵活、规则链复杂的场景。不建议使用，也就是95%以上的业务用不到。

代码示例：

#include <iostream>
#include <string>
#include <memory>

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

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

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

    bool interpret(const std::string& context) const override {
        return context.find(data) != std::string::npos;
    }
};

// 非终端表达式类
class OrExpression : public Expression {
private:
    std::shared_ptr<Expression> expr1;
    std::shared_ptr<Expression> expr2;

public:
    OrExpression(std::shared_ptr<Expression> expr1, std::shared_ptr<Expression> expr2)
        : expr1(expr1), expr2(expr2) {}

    bool interpret(const std::string& context) const override {
        return expr1->interpret(context) || expr2->interpret(context);
    }
};

// 使用示例
int main() {
    std::shared_ptr<Expression> robert = std::make_shared<TerminalExpression>("Robert");
    std::shared_ptr<Expression> john = std::make_shared<TerminalExpression>("John");
    std::shared_ptr<Expression> orExpression = std::make_shared<OrExpression>(robert, john);

    std::cout << "Is Robert or John present? " << orExpression->interpret("John") << std::endl;
    // 输出: Is Robert or John present? 1
    std::cout << "Is Robert or John present? " << orExpression->interpret("Alice") << std::endl;
    // 输出: Is Robert or John present? 0

    return 0;
}