C++中的解释器模式

目录

[解释器模式（Interpreter Pattern）](#解释器模式（Interpreter Pattern）)

实际应用

算术表达式解释器

布尔表达式解释器

总结

---

解释器模式（Interpreter Pattern）

解释器模式是一种行为设计模式，它定义了一种语言的文法表示，并使用解释器来解释这些文法。该模式适用于那些有特定语法规则的场景，比如编译器、正则表达式引擎和计算器。

实际应用

算术表达式解释器

算术表达式解释器 -- 可以解析和计算包含加法和减法的算术表达式。

#include <iostream>
#include <string>
#include <stack>
#include <memory>
#include <unordered_map>

// 抽象表达式
class Expression {
public:
    virtual ~Expression() = default;
    virtual int interpret(const std::unordered_map<char, int>& context) = 0;
};

// 终结符表达式（变量）
class VariableExpression : public Expression {
private:
    char name;
public:
    VariableExpression(char name) : name(name) {}
    int interpret(const std::unordered_map<char, int>& context) override {
        return context.at(name);
    }
};

// 非终结符表达式（加法）
class AddExpression : public Expression {
private:
    std::shared_ptr<Expression> left, right;
public:
    AddExpression(std::shared_ptr<Expression> left, std::shared_ptr<Expression> right) 
        : left(left), right(right) {}
    int interpret(const std::unordered_map<char, int>& context) override {
        return left->interpret(context) + right->interpret(context);
    }
};

// 非终结符表达式（减法）
class SubtractExpression : public Expression {
private:
    std::shared_ptr<Expression> left, right;
public:
    SubtractExpression(std::shared_ptr<Expression> left, std::shared_ptr<Expression> right) 
        : left(left), right(right) {}
    int interpret(const std::unordered_map<char, int>& context) override {
        return left->interpret(context) - right->interpret(context);
    }
};

// 客户端代码：解析并计算表达式
int main() {
    std::string expr = "a+b-c";
    std::unordered_map<char, int> context = {{'a', 5}, {'b', 3}, {'c', 2}};

    std::stack<std::shared_ptr<Expression>> stack;
    for (char token : expr) {
        if (isalpha(token)) {
            stack.push(std::make_shared<VariableExpression>(token));
        } else if (token == '+') {
            auto right = stack.top(); stack.pop();
            auto left = stack.top(); stack.pop();
            stack.push(std::make_shared<AddExpression>(left, right));
        } else if (token == '-') {
            auto right = stack.top(); stack.pop();
            auto left = stack.top(); stack.pop();
            stack.push(std::make_shared<SubtractExpression>(left, right));
        }
    }

    auto expression = stack.top();
    int result = expression->interpret(context);
    std::cout << "Result: " << result << std::endl;

    return 0;
}

布尔表达式解释器

布尔表达式解释器 -- 可以解析和计算包含与（AND ）和或（OR）的布尔表达式。

#include <iostream>
#include <string>
#include <stack>
#include <memory>
#include <unordered_map>

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

// 终结符表达式（变量）
class VariableExpression : public Expression {
private:
    std::string name;
public:
    VariableExpression(const std::string& name) : name(name) {}
    bool interpret(const std::unordered_map<std::string, bool>& context) override {
        return context.at(name);
    }
};

// 非终结符表达式（与操作）
class AndExpression : public Expression {
private:
    std::shared_ptr<Expression> left, right;
public:
    AndExpression(std::shared_ptr<Expression> left, std::shared_ptr<Expression> right) 
        : left(left), right(right) {}
    bool interpret(const std::unordered_map<std::string, bool>& context) override {
        return left->interpret(context) && right->interpret(context);
    }
};

// 非终结符表达式（或操作）
class OrExpression : public Expression {
private:
    std::shared_ptr<Expression> left, right;
public:
    OrExpression(std::shared_ptr<Expression> left, std::shared_ptr<Expression> right) 
        : left(left), right(right) {}
    bool interpret(const std::unordered_map<std::string, bool>& context) override {
        return left->interpret(context) || right->interpret(context);
    }
};

// 客户端代码：解析并计算布尔表达式
int main() {
    std::string expr = "a AND b OR c";
    std::unordered_map<std::string, bool> context = {{"a", true}, {"b", false}, {"c", true}};

    std::stack<std::shared_ptr<Expression>> stack;
    std::istringstream iss(expr);
    std::string token;
    while (iss >> token) {
        if (token == "a" || token == "b" || token == "c") {
            stack.push(std::make_shared<VariableExpression>(token));
        } else if (token == "AND") {
            auto right = stack.top(); stack.pop();
            auto left = stack.top(); stack.pop();
            stack.push(std::make_shared<AndExpression>(left, right));
        } else if (token == "OR") {
            auto right = stack.top(); stack.pop();
            auto left = stack.top(); stack.pop();
            stack.push(std::make_shared<OrExpression>(left, right));
        }
    }

    auto expression = stack.top();
    bool result = expression->interpret(context);
    std::cout << "Result: " << std::boolalpha << result << std::endl;

    return 0;
}

总结

解释器模式可以帮助我们定义和解释特定语言的语法规则，并将这些规则应用于不同的上下文。