Interpreter(解释器模式）行为型_interpret的种类-优快云博客

本文链接：https://blog.youkuaiyun.com/weixin_50866517/article/details/127265119

解释器模式

一、概述
- 二、结构

一、概述

描述：当不懂英文的中国人和不懂中文的外国人交流时会存在沟通障碍。这时有种翻译器能将两种语言进行转换各个对方国家语言，然后进行交流。

定义：通常当一个语言需要解释执行，并且你可以将该语言中的句子表示成为一个抽象的语法树时，可以使用解释器模式。

二、结构

在这里插入图片描述

抽象表达式（Abstract Expression）：定义解释器的接口，约定解释器的解释操作，主要包含解释方法 interpret()。
终结符表达式（Terminal Expression）：是抽象表达式的子类，用来实现文法中与终结符相关的操作，文法中的每一个终结符都有一个具体终结表达式与之相对应。
非终结符表达式（Nonterminal Expression）：也是抽象表达式的子类，用来实现文法中与非终结符相关的操作，文法中的每条规则都对应于一个非终结符表达式。
上下文（Context）：通常包含各个解释器需要的数据或是公共的功能，一般用来传递被所有解释器共享的数据，后面的解释器可以从这里获取这些值。

三、实例

//计算加减乘除
#include<iostream>
#include<map>
#include<stack>
using namespace std;

///抽象类表达式 通过map可以获取变量的值
class Expression
{
public:
    virtual int interpreter(map<char, int> var) = 0;
};

///变量的解释器
class VarExpression :public Expression
{
public:
    VarExpression(char key)
    {
        m_key = key;
    }
    virtual int interpreter(map<char, int> var)
    {
        return var[m_key];
    }
private:
    char m_key;
};

///抽象运算符号解析器 每个运算符号都只和自己左右连个数字有关系
///但左右两个数字有可能也是一个解析的结果，无论何种类型都是expression类的实现类
// 抽象运算符号解析器
class SymbolExpression :public Expression
{
public:
    SymbolExpression(Expression* leftExpression, Expression* rightExpression)
    {
        m_leftExpression = leftExpression;
        m_rightExpression = rightExpression;
    }
    ///因为sybmol 是让子类来实现 因此interpreter是一个默认的实现
    int interpreter(map<char, int> var)
    {
        return 0;
    }
protected:
    Expression* m_leftExpression;
    Expression* m_rightExpression;
};
// 加法解析器
class AddExpression :public SymbolExpression
{
public:
    AddExpression(Expression* leftExpression, Expression* rightExpression) :
        SymbolExpression(leftExpression, rightExpression)
    {

    }
    virtual int interpreter(map<char, int> var)
    {
        return m_leftExpression->interpreter(var) + m_rightExpression->interpreter(var);
    }
};

// 减法解析器
class SubExpression :public SymbolExpression
{
public:
    SubExpression(Expression* leftExpression, Expression* rightExpression) :
        SymbolExpression(leftExpression, rightExpression)
    {

    }
    virtual int interpreter(map<char, int> var)
    {
        return m_leftExpression->interpreter(var) - m_rightExpression->interpreter(var);
    }
};


// 解析器封装类
class Calculator
{
public:
    Calculator(string expStr)
    {
        stack<Expression*> stack;
        Expression* left = nullptr;
        Expression* right = nullptr;
        for (int i = 0; i < expStr.size(); i++)
        {
            switch (expStr[i])
            {
            case '+':
                left = stack.top();
                stack.pop();
                right = new VarExpression(expStr[++i]);
                stack.push(new AddExpression(left, right));
                break;
            case '-':
                left = stack.top();
                stack.pop();
                right = new VarExpression(expStr[++i]);
                stack.push(new SubExpression(left, right));
                break;
            default:
                stack.push(new VarExpression(expStr[i]));
            }
        }
        m_expression = stack.top();
    }
    int run(map<char, int> var)
    {
        return m_expression->interpreter(var);
    }
private:
    Expression* m_expression;
};

///解释器模式
int main()
{
    cout << "interpreter patterns" << endl;
    ///利用解释器模式计算表达式a+b-c
    Calculator calc("a-b+c");
    map<char, int> var1;
    var1.insert(make_pair('a', 10));
    var1.insert(make_pair('b', 5));
    var1.insert(make_pair('c', 7));
    cout << calc.run(var1) << endl;

    map<char, int> var2;
    var2.insert(make_pair('a', 8));
    var2.insert(make_pair('b', 1));
    var2.insert(make_pair('c', 50));
    cout << calc.run(var2) << endl;
}