23、解释器模式（Interpreter）

解释器模式（Interpreter）是一种行为型设计模式，主要用于定义语言的文法，并使用该文法来解释句子。它提供了一个解释器来解释特定的语言表达式。

特点：

1、文法定义：通过表达式类的组合来定义文法。
2、可扩展性：新的文法规则可以通过添加新的类来实现。
3、递归结构：表达式通常使用递归结构来处理。

适用场景：

1、当需要对特定的文法进行解释和处理时。
2、当有很多重复出现的语句需要解析时。

示例：

假设有一个简单的数学表达式解析器，只支持加法和减法。

//g++ -o test main.cpp 
//
#include <iostream>
#include <string>
#include <map>
#include <memory>

// 抽象表达式类
class Expression {
public:
    virtual int interpret(std::map<std::string, int>& context) = 0;
};

// 变量表达式
class Variable : public Expression {
private:
    std::string name;
public:
    Variable(std::string name) : name(name) {}
    
    int interpret(std::map<std::string, int>& context) override {
        return context[name];
    }
};

// 加法表达式
class Addition : public Expression {
private:
    Expression* left;
    Expression* right;
public:
    Addition(Expression* left, Expression* right) : left(left), right(right) {}
    
    int interpret(std::map<std::string, int>& context) override {
        return left->interpret(context) + right->interpret(context);
    }
};

// 减法表达式
class Subtraction : public Expression {
private:
    Expression* left;
    Expression* right;
public:
    Subtraction(Expression* left, Expression* right) : left(left), right(right) {}
    
    int interpret(std::map<std::string, int>& context) override {
        return left->interpret(context) - right->interpret(context);
    }
};

int main() {
    // 创建上下文
    std::map<std::string, int> context;
    context["x"] = 5;
    context["y"] = 10;

    // 表达式：x + y - x
    Expression* expression = new Subtraction(
        new Addition(
            new Variable("x"),
            new Variable("y")
        ),
        new Variable("x")
    );

    std::cout << "Result: " << expression->interpret(context) << std::endl; // 输出: 10

    // 清理
    delete expression;
    return 0;
}

在这个例子中，Expression 是一个抽象类，Variable、Addition 和 Subtraction 是具体的表达式类。它们组合在一起，形成一个解析器，能够对简单的数学表达式进行解析和计算。这个模式适合用在需要对复杂语法或表达式进行解释的场景。