设计模式-第二十三章-解释器模式

一、UML图

二、包含的角色

AbstractExpression 抽象表达式：声明一个抽象的解释操作，并定义一个抽象的解释方案，其具体的实现在各个具体的子类解释器中完成

TerminalExpression 终结符表达式：实现文法中终结符有关的解释操作。文法中每一个终结符都有一个具体的终结表达式与之对应

NoterminalExpression 非终结符表达式：实现文法中非终结符有关的解释操作

Context 环境角色：上下文环境，包含解释器之外的全局信息

三、特点

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

也就是说如果一种特定类型的问题发生的概率足够高，那么可能就值得该问题的各个实例表述为一个简单语言中的句子。这样就可以构建一个解释器，该解释器通过解释这些句子来解决该问题。

使用场景：当有一个语言需要解释执行，并且你可将改语言中的句子表示为一个抽象语法语树时，可以使用解释器模式。

优点：用了解释器模式，就意味着可以很容易地改变和扩展文法，因为该模式使用类来表示文法规则，你可使用继承来改变或扩展该文法。也比较容易实现文法，因为定义抽象语法树种各个节点的类的实现大体类似，这些类都易于直接边写。

缺点：解释器模式为文法中的每一条规则至少定义了一个类，因此包含许多规则的文法可能难以管理和维护。建议当文法非常复杂时，使用其他的技术如语法分析程序或编译器生成器来处理

四、代码实现

AbstractExpression 类

#pragma once
#include "Context.h"

class AbstractExpression
{
public:
    virtual ~AbstractExpression() {}
    virtual int Interpret(Context *ctx) = 0;
};

TerminalExpression类

#pragma once
#include "AbstractExpression.h"
#include <iostream>

class TerminalExpression : public AbstractExpression
{ // 终结符表达式
public:
    int Interpret(Context *context) override
    {
        std::cout << "TerminalExpression: " << context->input() << ", " << context->output() << std::endl;
        return 0;
    }
};

NoterminalExpression类

#pragma once
#include "AbstractExpression.h"
#include <iostream>

class NonterminalExpression : public AbstractExpression
{ // 非终结符表达式
private:
    AbstractExpression *expression;

public:
    NonterminalExpression(AbstractExpression *e)
    {
        expression = e;
    }
    int Interpret(Context *context) override
    {
        std::cout << "NonterminalExpression: " << context->input() << ", " << context->output() << std::endl;
        expression->Interpret(context);
        return 0;
    }
};

Context类

#pragma once
#include <string>

class Context
{ 

public:
    void setinput(std::string i)
    {
        input_ = i;
    }
    std::string input()
    {
        return input_;
    }

    void setoutput(std::string o)
    {
        output_ = o;
    }
    std::string output()
    {
        return output_;
    }

    // 包含解释器之外的全局信息
private:
    std::string input_;
    std::string output_;
};

main

#include "TerminalExpression.h"
#include "NonterminalExpression.h"

#include <iostream>
int main()
{
    Context *c = new Context();
    c->setinput("Hello");
    c->setoutput("World");

    AbstractExpression *exp1 = new TerminalExpression();
    AbstractExpression *exp2 = new NonterminalExpression(exp1);
    exp1->Interpret(c); // TerminalExpression: Hello, World
    exp2->Interpret(c); // NonterminalExpression: Hello, World
                        // TerminalExpression: Hello, World
    delete exp1;
    delete exp2;
    return 0;
}