【设计模式】解释器模式

主页传送门： 传送

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 
#include 
#include 
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;
}

运行结果：

4.解释器模式优缺点

解释器模式的优点主要包括：

1. 灵活性高：解释器模式可以通过定义语言的文法和解释器，灵活地扩展和改变语言的解析和执行规则。
2. 易于扩展：通过增加新的终结符表达式和非终结符表达式，可以很容易地扩展语言的表达能力。
3. 可读性好：解释器模式将语言的语法规则抽象成了类的结构，使得语法规则更加易于理解和维护。

解释器模式的缺点主要包括：

1. 执行效率低：由于解释器模式需要递归地解释和执行表达式，因此在处理复杂表达式时可能会导致性能问题。
2. 可利用场景比较少：解释器模式通常适用于特定领域的语言解析和执行，因此其应用场景相对较少。
3. 对于复杂的文法比较难维护：当语言的语法规则变得复杂时，解释器模式的实现和维护难度也会相应增加。

总的来说，解释器模式适用于需要解析和执行特定领域语言的场景，但在使用时需要权衡其优缺点，并根据实际需求进行选择和设计。

5.解释器模式适用场景

解释器模式适用于以下场景：

1. 需要定义一个语言，并且为该语言定义一个解释器，用于解析和执行该语言中的句子。
2. 某些特定类型的问题发生频率足够高，需要专门构建一个解释器来处理这些问题。例如，日志处理、配置文件解析等。

在这些场景下，解释器模式可以帮助我们构建一个灵活、可扩展的语言解析和执行系统，使得语言的解析和执行更加高效、可靠。

6.解释器模式总结

     解释器模式是一种用于构建解释器的设计模式，它允许我们定义一个语言的文法规则，并构建一个解释器来解析和执行该语言中的句子。通过将语言的语法规则抽象成类的结构，解释器模式使得语言的解析和执行更加灵活、可扩展。在使用解释器模式时，需要注意其执行效率、可维护性等方面的问题，并根据实际需求进行选择和设计。

如果喜欢的话，欢迎 关注 点赞 评论 收藏 一起讨论
你的支持就是我✍️创作的动力！