023 --- 第27章 解释器模式

简述：

　　解释器模式：给定一个语言，定义它的文法的一种表示，并定义一个解释器，这个解释器使用该表示来解释语言中的句子。

　　解释器模式包括：上下文类、抽象表达式类、终结符表达式类、非终结符表达式类。

　　　　上下文类：包含解释器之外的一些全局信息。

　　　　抽象表达式类：声明一个抽象的解释操作，这个接口作为抽象语法树中所有的节点共享。

　　　　终结符表达式类：继承自抽象表达式类，实现与文法中的终结符相关联的解释操作。

　　　　非终结符表达式类：继承自抽象表达式类，为文法中的非终结符实现解释操作，对文法中每一条规则R1、R2……RN都需要一个具体的非终结符表达式类。

 

应用场景：定义一种语言，定义一种解释其文法的解释器，将复杂问题简单化

 

注：开发环境调整为VS2017，操作系统win11

解释器模式：

#include <iostream>
#include <list>
using namespace std;

// 上下文类
class CContext
{
private:
    string m_szInput;
    string m_szOutPut;

public:
    void SetInput(string szInput) { m_szInput = szInput; }

    string GetInput() { return m_szInput; }

    void SetOutPut(string szOutPut) { m_szOutPut = szOutPut; }

    string GetOutPut() { return m_szOutPut; }

};

// 抽象表达式类
class CAbstractExpression
{
public:
    virtual void Interpret(CContext* pContext) = 0;
};

// 终结符表达式类
class CTerminalExpression : public CAbstractExpression
{
public:
    virtual void Interpret(CContext* pContext) { cout << "终端解释器" << endl; }
};

// 非终结符表达式类
class CNonterminalExpression : public CAbstractExpression
{
public:
    virtual void Interpret(CContext* pContext) { cout << "非终端解释器" << endl; }
};

int main()
{
    CContext Context;
    list<CAbstractExpression*> list;
    CTerminalExpression TerminalExpression1;
    list.push_back(&TerminalExpression1);
    CNonterminalExpression NonterminalExpression;
    list.push_back(&NonterminalExpression);
    CTerminalExpression TerminalExpression2;
    list.push_back(&TerminalExpression2);
    CTerminalExpression TerminalExpression3;
    list.push_back(&TerminalExpression3);

    for (auto Expression : list)
        Expression->Interpret(&Context);

    system("pause");
    return 0;
}

 

输出结果：

 

 

 

 

例：音乐解释器

代码如下：

 

#include <iostream>
#include <list>
#include <string>
using namespace std;


// 演奏内容（上下文类）
class CPlayContext
{
private:
    string m_szText; // 演奏文本

public:
    void SetText(string szText) { m_szText = szText; }

    string GetText()
    { return m_szText; }
};

// 抽象表达式类
class CExpression
{
public:
    // 解释器
    void Interpret(CPlayContext* pContext)
    {
        if (pContext->GetText().length() == 0)
            return;
        else
        {
            string szPlayKey = pContext->GetText().substr(0, 1);
            char cKey = szPlayKey[0];
            pContext->SetText(pContext->GetText().substr(2));
            double fPlayValue = atof(pContext->GetText().substr(0, pContext->GetText().find_first_of(' ')).c_str());
            pContext->SetText(pContext->GetText().substr(pContext->GetText().find_first_of(' ') + 1));
        
            Excute(cKey, fPlayValue);
        }
    }

    // 执行
    virtual void Excute(char szKey, double fValue) = 0;
};

// 音符类（终结符表达式类）
class CNote : public CExpression
{
    void Excute(char cKey, double fValue)
    {
        int nNote = 0;

        switch (cKey)
        {
        case 'C':
            nNote = 1;
            break;
        case 'D':
            nNote = 2;
            break;
        case 'E':
            nNote = 3;
            break;
        case 'F':
            nNote = 4;
            break;
        case 'G':
            nNote = 5;
            break;
        case 'A':
            nNote = 6;
            break;
        case 'B':
            nNote = 7;
            break;
        }
        cout << nNote << " ";
    }
};

// 音阶类（终结符表达式类）
class CScale : public CExpression
{
public:
    void Excute(char cKey, double fValue)
    {
        string m_szScale;

        switch ((int)fValue)
        {
        case 1:
            m_szScale = "低音";
            break;
        case 2:
            m_szScale = "中音";
            break;
        case 3:
            m_szScale = "高音";
            break;
        }
        cout << m_szScale << " ";
    }
};

// 音速类（终结符表达式类）
class CSpeed : public CExpression
{
public:
    void Excute(char cKey, double fValue)
    {
        string m_szSpeed;

        if (fValue < 500)
            m_szSpeed = "快速";
        else if(fValue >= 1000)
            m_szSpeed = "慢速";
        else
            m_szSpeed = "中速";

        cout << m_szSpeed << " ";
    }
};

// 缺少非终结符表达式的子类，如果做到不改动客户端，C#可以用简单工厂加反射，C++可以用动态创建对象等技术，之前有写，这里就没有重复写

int main()
{
    CPlayContext Context;
    CScale Scale;
    CNote Note;
    CSpeed Speed;
    // 音乐-上海滩
    cout << "上海滩：" << endl;
    Context.SetText("T 500 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");

    CExpression* pExpression = NULL;
    try
    {
        while (Context.GetText().length() > 0)
        {
            char c = Context.GetText().substr(0, 1)[0];
            switch (c)
            {
            case 'O':
                pExpression = &Scale;
                break;
            case 'T':
                pExpression = &Speed;
                break;
            case 'C':
            case 'D':
            case 'E':
            case 'G':
            case 'A':
            case 'B':
            case 'P':
                pExpression = &Note;
                break;
            default:
                cout << endl << "播放完成" << endl;
                system("pause");
                return 0;
            }
            pExpression->Interpret(&Context);
        }
    }
    catch (exception ex)
    {
        cout << ex.what() << endl; // 第19次取出长度错误，所以报错
    }

    system("pause");
    return 0;
}

 

输出结果：