设计模式15之c++解释器模式(含示例代码)

解释器模式是一种行为型设计模式，它定义了一种语言文法，并且定义了一个解释器，用来解释这种语言中的表达式。解释器模式可以用于实现编译器、数学公式计算器等应用。

下面是一个使用 C++ 实现解释器模式的示例代码：

#include <iostream>
#include <map>
#include <stack>
#include <string>
#include <vector>
// 表达式抽象类
class Expression {
public:
    virtual ~Expression() {}
    virtual int Interpret(std::map<std::string, int>& context) = 0;
};
// 终结符表达式类：变量表达式
class VariableExpression : public Expression {
public:
    VariableExpression(std::string name) : name_(name) {}
    int Interpret(std::map<std::string, int>& context) override {
        if (context.find(name_) != context.end()) {
            return context[name_];
        } else {
            return 0;
        }
    }
private:
    std::string name_;
};
// 终结符表达式类：常量表达式
class ConstantExpression : public Expression {
public:
    ConstantExpression(int value) : value_(value) {}
    int Interpret(std::map<std::string, int>& context) override {
        return value_;
    }
private:
    int value_;
};
// 非终结符表达式类：加法表达式
class AddExpression : public Expression {
public:
    AddExpression(Expression* left, Expression* right) : left_(left), right_(right) {}
    ~AddExpression() {
        delete left_;
        delete right_;
    }
    int Interpret(std::map<std::string, int>& context) override {
        return left_->Interpret(context) + right_->Interpret(context);
    }
private:
    Expression* left_;
    Expression* right_;
};
// 非终结符表达式类：减法表达式
class SubExpression : public Expression {
public:
    SubExpression(Expression* left, Expression* right) : left_(left), right_(right) {}
    ~SubExpression() {
        delete left_;
        delete right_;
    }
    int Interpret(std::map<std::string, int>& context) override {
        return left_->Interpret(context) - right_->Interpret(context);
    }
private:
    Expression* left_;
    Expression* right_;
};
// 解释器类
class Interpreter {
public:
    Interpreter(std::string expression) {
        std::vector<std::string> tokens = Split(expression);
        for (auto token : tokens) {
            if (token == "+") {
                Expression* right = stack_.top();
                stack_.pop();
                Expression* left = stack_.top();
                stack_.pop();
                Expression* add_expression = new AddExpression(left, right);
                stack_.push(add_expression);
            } else if (token == "-") {
                Expression* right = stack_.top();
                stack_.pop();
                Expression* left = stack_.top();
                stack_.pop();
                Expression* sub_expression = new SubExpression(left, right);
                stack_.push(sub_expression);
            } else {
                Expression* variable_expression = new VariableExpression(token);
                stack_.push(variable_expression);
            }
        }
        syntax_tree_ = stack_.top();
    }
    ~Interpreter() {
        delete syntax_tree_;
    }
    int Interpret(std::map<std::string, int>& context) {
        return syntax_tree_->Interpret(context);
    }
private:
    std::vector<std::string> Split(std::string str) {
        std::vector<std::string> tokens;
        std::string token;
        for (auto ch : str) {
            if (ch == '+' || ch == '-') {
                if (token != "") {
                    tokens.push_back(token);
                    token = "";
                }
                tokens.push_back(std::string(1, ch));
            } else {
                token += ch;
            }
        }
        if (token != "") {
            tokens.push_back(token);
        }
        return tokens;
    }
private:
    std::stack<Expression*> stack_;
    Expression* syntax_tree_;
};
int main() {
    // 构建语法树
    std::string expression = "a+b-c";
    Interpreter interpreter(expression);
    // 构建环境
    std::map<std::string, int> context;
    context["a"] = 1;
    context["b"] = 2;
    context["c"] = 3;
    // 计算表达式
    int result = interpreter.Interpret(context);
    std::cout << expression << " = " << result << std::endl;
    return 0;
}

在上面的代码中，我们首先定义了一个 Expression 抽象类，其中包含了一个 Interpret() 纯虚函数。终结符表达式类 VariableExpression 和 ConstantExpression 实现了 Interpret() 函数，以完成变量和常量的解释。非终结符表达式类 AddExpression 和 SubExpression 实现了 Interpret() 函数，以完成加法和减法的解释。

Interpreter 类是解释器类，它将输入的表达式转化为语法树，并提供 Interpret() 函数用于解释表达式。在 main() 函数中，我们首先构建了一个语法树，然后构建了一个环境，并将环境传递给解释器，最后计算表达式并输出结果。

解释器模式的优点在于它可以灵活地扩展语言的文法，并且可以方便地实现编译器、数学公式计算器等应用。但是，由于解释器模式需要构建语法树，因此它的性能可能会受到一定的影响。