解释器模式

Posted 2022-04-04 manual-linux

一 概念

• 解释器模式，给定一个语言，定义它的文法的一种表示，并定义一个解释器，这个解释器使用该表示来解释语言中的句子。
• 解释器要解决的问题是，如果一种特定类型的问题发生的频率足够高，那么可能就值得将该问题的各个实例表述为一个简单语言中的句子，这样就可以构建一个解释器，该解释器通过解释这些句子来解决该问题。

二 UML图

• Context 包含解释器之外的一些全局信息，对全局的一些内容进行描述
• AbstractExpression 抽象表达式，声明一个抽象的解释操作，这个接口为抽象语法树中所有的节点所共享。
• TerminalExpression 终结符表达式，实现与文法中的终结符相关联的解释操作。
• NonterminalExpression 非终结符表达式，为文法中的非终结符实现解释操作，对文法中每一条规则R1,R2，。。。Rn都需要一个具体的非终结符表达式类。

三 C++代码实现

#include "pch.h"
#include <iostream>
#include <string>
#include <vector>
#include <sstream>
using namespace std;

template <typename elemType>
elemType stringToNum(const string& str)

    istringstream iss(str);
    elemType num;
    iss >> num;
    return num;


//包含解释器之外的一些全局信息
class PlayContext

public:
    void SetPlayContext(const string text)
    
        this->str_text = text;
    
    string GetPlayContext() const
    
        return this->str_text;
    
private:
    string str_text;
;
//表达式类 AbstractExpression
//抽象表达式，声明一个抽象的解释操作，这个接口为抽象语法树中所有的节点所共享
class Expression

public:
    virtual void Interpret(PlayContext* context)
    
        string buf;
        string s2;
        if (context->GetPlayContext().size() == 0)
        
            return;
        
        else
        
            vector<string> vec;
            stringstream ss(context->GetPlayContext());
            while (ss >> buf)
            
                vec.push_back(buf);
            

            //这里是C++的字符串处理
            string playKey = vec[0];
            double playValue = stringToNum<double>(vec[1]);
            this->Excute(playKey, playValue);

            vec.erase(vec.begin(), vec.begin() + 2);
            vector<string>::iterator it;
            for (it = vec.begin(); it != vec.end(); it++)
            
                s2 += *it;
                if (it != vec.end() - 1)
                    s2 += " ";
            
            context->SetPlayContext(s2);
        
    
    virtual void Excute(string key, double value) = 0;
;

//音符类
//TerminalExpression 终结符表达式，实现与文法中的终结符相关联的解释操作
class Note : public Expression

    void Excute(string key, double value) override
    
        string note = "";
        switch (key[0])
        
        case 'C':
            note = "1";
            break;
        case 'D':
            note = "2";
            break;
        case 'E':
            note = "3";
            break;
        case 'F':
            note = "4";
            break;
        case 'G':
            note = "5";
            break;
        case 'A':
            note = "6";
            break;
        case 'B':
            note = "7";
            break;
        default:
            break;
        
        cout << note << " ";
    
;

class Scale : public Expression

public:
    void Excute(string key, double value) override
    
        string scale = "";
        switch (static_cast<int>(value))
        
        case 1:
            scale = "低音";
            break;
        case 2:
            scale = "中音";
            break;
        case 3:
            scale = "高音";
            break;
        default:
            break;
        
        cout << scale << " ";
    
;

int main()

    PlayContext* context = new PlayContext();
    cout << "上海滩: " << endl;
    context->SetPlayContext("O 2 E 0.5 G 0.5 A 3 E 0.5 G 0.5 D 3 E 0.5 G 0.5 A 0.5 O 3 C 1 O 2 A 0.5 G 1 C 0.5 E 0.5 D 3 ");
    while (context->GetPlayContext().size() > 0)
    
        Expression* expression = nullptr;
        char c = context->GetPlayContext()[0];

        switch (c)
        
        case 'O':
            //当首字段是O时，则表达式实例化为音阶
            expression = new Scale();
            break;
        case 'C':
        case 'D':
        case 'E':
        case 'F':
        case 'G':
        case 'A':
        case 'B':
        case 'P':
            //当首字母是CDEFGAB，以及休止符P时，则实例化为音符
            expression = new Note();
            break;
        
        expression->Interpret(context);
        delete expression;
    
    system("pause");

补充的另外一个例子

• 一个简单加减法运算器的实例

//一个简单加减法运算器的实例
#include "pch.h"
#include <iostream>
#include <string>
#include <vector>

using namespace std;

//抽象的表达式对象以及Context对象
//用于保存计算的中间结果以及当前执行的操作符
class Context

public:
    Context()
        :m_value(0), m_operator('\\0')
    
    void SetOperator(char type)
    
        this->m_operator = type;
    
    char GetOperator() const
    
        return this->m_operator;
    
    void SetValue(int number)
    
        this->m_value = number;
    
    int GetValue() const
    
        return this->m_value;
    
private:
    int m_value;
    char m_operator;
;

//表示所有表达式的抽象接口
class IExpression

public:
    virtual void Eval(Context* p) = 0;
;
//拆分表达式的元素
class Operator : public IExpression
 
public:
    Operator(char op)
    
        this->m_op = op;
    
    void Eval(Context* pContext) override
    
        pContext->SetOperator(this->m_op);
    
private:
    char m_op;
;

//拆分操作数
class Operand : public IExpression

public:
    Operand(int number)
    
        this->m_num = number;
    
    void Eval(Context* pContext) override
    
        switch (pContext->GetOperator())
        
        case '\\0':
            pContext->SetValue(this->m_num);
            break;
        case '+':
            pContext->SetValue(this->m_num + pContext->GetValue());
            break;
        case '-':
            pContext->SetValue(pContext->GetValue() - this->m_num);
            break;
        default:
            break;
        
    
private:
    int m_num;
;

class Calculator

public:
    Calculator()
    
    int Calc(string expression)
    
        Context* pContext = new Context;
        vector<IExpression*> tree;  //语法解析树
        for (int ix = 0; ix < expression.size(); ++ix)
        
            if (expression[ix] == '+' || expression[ix] == '-')
            
                tree.push_back(new Operator(expression[ix]));
                cout << "第" << ix << "次压入的符号是" << expression[ix] << endl;
            
            else
            
                tree.push_back(new Operand(static_cast<int>(expression[ix] - 48)));
                cout << "第" << ix << "次压入的数字是" << static_cast<int>(expression[ix] - 48) << endl;
            
        
        for (vector<IExpression*>::iterator iter = tree.begin(); iter != tree.end(); ++iter)
        
            (*iter)->Eval(pContext);
        
        return pContext->GetValue();
    
;

int main()

    Calculator* pc = new Calculator();
    cout << "1+4-2+6+9-5-2-1+1+2= " << pc->Calc("1+4-2+6-9-5-2-1+1+2") << endl;
    system("pause");
    return 0;

运行结果

参考资料：
1 https://blog.csdn.net/xiqingnian/article/details/42222369 《大话设计模式C++实现-第27章-解释器模式》
2 https://www.cnblogs.com/hjj-fighting/p/10514935.html 《c++ string 转double》