【设计模式】解释器模式

news2024/11/20 0:40:55

文章目录

1.解释器模式定义
2.解释器模式的角色
3.解释器模式实战案例
- 3.1.场景说明
- 3.2.结构类图
- 3.3.代码实现
4.解释器模式优缺点
5.解释器模式适用场景
6.解释器模式总结

主页传送门：💁 传送

1.解释器模式定义

解析器模式（Interpreter Pattern）是一种按照规定语法进行解析的方案，在现在项目中使用较少，其定义如下：

Given a language, define a representation for its grammar along with an interpreter that uses the representation to interpret sentences in the language.

即：给定一门语言，定义他的文法的表示，并定义一个解释器，该解释器使用该表示来解释语言中的句子。
其通用类图如下：
在这里插入图片描述

2.解释器模式的角色

解释器模式所涉及到的角色有：

Context 解释器上下文环境类
用来存储解释器的上下文环境，包含解释器之外的一些全局信息，比如需要解释的文法等
AbstractExpression 解释器抽象类，抽象表达式
这个接口为抽象语法树中所有节点所共享
TerminalExpression 解释器具体实现类，终结符表达式
实现与文法中的终结符相关联的解释操作
一个句子中的每个终结符需要该类的一个实例
NonterminalExpression 解释器具体实现类，非终结符表达式
对文法中的每一个规则R :: = RR…R都需要一个NonterminalExpression类。
为从R到R的每个符号都维护一个AbstractExpression类型的实例变量。
为文法中的非终结符实现解释操作。解释一般要递归地调用表示R到R的那些对象的解释操作。
Client 客户
构建(或被给定)表示该文法定义的语言中一个特定的句子的抽象语法树。该抽象语法树由NonterminalExpression和TerminalExpression的实例装配而成。
调用解释操作。

3.解释器模式实战案例

3.1.场景说明

实现音乐解释器，定义一套规则：

T表示速度，以毫秒为单位；

O 表示音阶， O1 表示低音阶， O2 表示中音阶， O3 表示高音阶；

P 表示休止符；

C D E F G A B 表示 “Do-Re-Mi-Fa-So-La-Ti”；

音符长度1表示一拍，2表示二拍，0.5表示半拍，0.25表示四分之一拍；

所有字母和数字都要用半角空格分开。

3.2.结构类图

使用解释器模式来实现的结构图如下所示：：
在这里插入图片描述

3.3.代码实现

#include <iostream>
#include <sstream>
#include <vector>
using namespace std;
 
//演奏内容类
class PlayContext {
public:
    void SetText(string _text) {
        text = _text;
    }
    string GetText() {
        return text;
    }
private:
    string text;
};
 
//抽象表达式类
class Expression {
public:
    virtual void Excute(string key, string value) = 0;
    void Interpret(PlayContext* context) {
        if (context->GetText().length() == 0)
            return;
        else {
            vector<string> vs;
            stringstream ss(context->GetText());  //使用字符串构造一个stringstream
            //按空格分割字符串
            string buf;
            while (ss >> buf)
                vs.push_back(buf);
            //解释前两个字符串
            Excute(vs[0], vs[1]);
            //拼接剩下的字符串
            string tmp;
            vs.erase(vs.begin(), vs.begin() + 2);
            for (vector<string>::iterator it = vs.begin(); it != vs.end(); it++) {
                tmp += *it;
                if (it < vs.end() - 1)
                    tmp += " ";
            }
            //更新字符串
            context->SetText(tmp);
        }
    }
};
 
//音符类
class Note :public Expression {
public:
    void Excute(string key, string value) {
        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:
    virtual void Excute(string key, string value) {
        string scale = " ";
        switch (value[0])
        {
        case'1':
            scale = "低音"; break;
        case'2':
            scale = "中音"; break;
        case'3':
            scale = "高音"; break;
        default:
            break;
        }
        cout << scale << " ";
    }
};
 
//音速类
class Speed : public Expression
{
public:
    void Excute(string key, string value)
    {
        int v = stoi(value);
        if (v < 500)
            cout << "快速 ";
        else if (v > 1000)
            cout << "慢速 ";
        else
            cout << "中速 ";
    }
};
 
int main()
{
    PlayContext context;
    cout << "上海滩: " << endl;
    context.SetText("T 600 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");
    Expression* expression = NULL;
    while (context.GetText().length() > 0)
    {
        char str = context.GetText()[0];
        switch (str)
        {
        case'O':
            expression = new Scale; break;
        case'T':
            expression = new Speed; break;
        case'C':
        case'D':
        case'E':
        case'F':
        case'G':
        case'A':
        case'B':
        case'P':
            expression = new Note; break;
        default:
            break;
        }
        expression->Interpret(&context);
        delete expression;
    }
    cout << endl;
    return 0;
}