解释器模式

解释器模式
【1】什么是解释器模式？

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

【2】解释器模式代码示例：

（1）代码示例1：

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

class Context;

class AbstractExpression
{
public:
    virtual void interpret(Context *) = 0;
};

class TerminalExpression : public AbstractExpression
{
public:
    void interpret(Context *context)
    {
        cout << "终端解释器" << endl;
    }
};

class NonterminalExpression : public AbstractExpression
{
public:
    void interpret(Context *context)
    {
        cout << "非终端解释器" << endl;
    }
};

class Context
{
public:
    string input, output;
};

int main()
{
    Context *context = new Context(); 
    list<AbstractExpression*>  lt;
    lt.push_back(new TerminalExpression());
    lt.push_back(new NonterminalExpression());
    lt.push_back(new TerminalExpression());
    lt.push_back(new TerminalExpression());
    
    for (list<AbstractExpression*>::iterator iter = lt.begin(); iter != lt.end(); iter++)
    {
        (*iter)->interpret(context);
    }
    
    return 0;
}
// Result:
/*
终端解释器
非终端解释器
终端解释器
终端解释器
*/

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

class Context
{
private:
    map<string, int> valueMap;

public:
    void addValue(string key,int value)
    {       
        valueMap.insert(std::pair<string, int>(key, value));   // 插入构建项
    }

    int getValue(string key)
    {
        return valueMap[key]; // 解析值
    }
};

class AbstractExpression
{
public :
     virtual int interpreter(Context context) = 0;
};

class AddNonterminalExpression : public AbstractExpression
{
private :
    AbstractExpression *left;
    AbstractExpression *right;

public:
    AddNonterminalExpression(AbstractExpression *left, AbstractExpression *right)
        : left(left)
        , right(right)
    {
    }

    int interpreter(Context context)
    {
        return (left->interpreter(context)) + (right->interpreter(context));
    }
};

class SubtractNonterminalExpression : public AbstractExpression
{
private :
    AbstractExpression *left;
    AbstractExpression *right;

public:
    SubtractNonterminalExpression(AbstractExpression *left, AbstractExpression *right)
        : left(left)
        , right(right)
    {
    }

    int interpreter(Context context)
    {
        return (left->interpreter(context)) - (right->interpreter(context));
    }
};

class TerminalExpression : public AbstractExpression
{
private :
    int i;
public :
    TerminalExpression(int i) : i(i)
    {
    }

    int interpreter(Context context)
    {
        return i;
    }
};

int main()
{  
    // a - b + c
    Context context;
    context.addValue("a", 10);
    context.addValue("b", 8);
    context.addValue("c", 2);

    SubtractNonterminalExpression *subtractValue = 
        new SubtractNonterminalExpression(new TerminalExpression(context.getValue("a")), new TerminalExpression(context.getValue("b")));

    AddNonterminalExpression *addValue = new AddNonterminalExpression(subtractValue, new TerminalExpression(context.getValue("c")));

    cout << subtractValue->interpreter(context);  // 10 - 8 = 2
    cout << addValue->interpreter(context);  // 2 + 2 = 4
    
    return 0;  
}

【3】应用

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