解释器模式：

　　从名称上来看看这个模式，个人的最初理解“解释器”和Google的中英翻译功能类似。如果有一天你去国外旅游去了，比如去美国吧，美国人是讲英语的，我们是讲汉语的，如果英语听不懂，讲不好，估计沟通就完蛋了，不能沟通，估计玩的就很难尽兴了，因为有很多景点的解说你可能不明白（没有中文翻译的情况下，一般情况会有的）。所以我们需要一个软件，可以把中英文互译，那彼此就可以更好的理解对方的意思，我感觉翻译软件也可以称得上是解释器，把你不懂的解释成你能理解的。我们写代码，需要编译器把我们写的代码编译成机器可以理解的机器语言，从这方面来讲，C#的编译器也是一种解释器。

解释器模式的角色：

  1. 抽象解释器（AbstractExpression）：定义解释器的接口，约定解释器的解释操作。其中的Interpret接口，正如其名字那样，它是专门用来解释该解释器所要实现的功能。
  2. 终结符表达式（TermialExpression）：实现了抽象表达式角色所要求的接口，主要是一个interpret()方法；文法中的每一个终结符都有一个具体终结表达式与之相对应。比如有一个简单的公式R=R1+R2，在里面R1和R2就是终结符，对应的解析R1和R2的解释器就是终结符表达式。
  3. 非终结符表达式（NonterminalExpression）：文法中的每一条规则都需要一个具体的非终结符表达式，非终结符表达式一般是文法中的运算符或者其他关键字，比如公式R=R1+R2中，“+”就是非终结符，解析“+”的解释器就是一个非终结符表达式。
  4. 环境角色（Context）：这个角色的任务一般是用来存放文法中各个终结符所对应的具体值，比如R=R1+R2，我们给R1赋值100，给R2赋值200。这些信息需要存放到环境角色中，很多情况下我们使用Map来充当环境角色就足够了。

优点：

  1. 易于改变和扩展文法。
  2. 每一条文法规则都可以表示为一个类，因此可以方便地实现一个简单的语言。
  3. 实现文法较为容易。在抽象语法树中每一个表达式节点类的实现方式都是相似的，这些类的代码编写都不会特别复杂，还可以通过一些工具自动生成节点类代码。
  4. 增加新的解释表达式较为方便。如果用户需要增加新的解释表达式只需要对应增加一个新的终结符表达式或非终结符表达式类，原有表达式类代码无须修改，符合“开闭原则”。

缺点：

  1. 对于复杂文法难以维护。在解释器模式中，每一条规则至少需要定义一个类，因此如果一个语言包含太多文法规则，类的个数将会急剧增加，导致系统难以管理和维护，此时可以考虑使用语法分析程序等方式来取代解释器模式。
  2. 执行效率较低。由于在解释器模式中使用了大量的循环和递归调用，因此在解释较为复杂的句子时其速度很慢，而且代码的调试过程也比较麻烦。

解释器模式的应用场景：

  1. 当一个语言需要解释执行，并可以将该语言中的句子表示为一个抽象语法树的时候，可以考虑使用解释器模式（如XML文档解释、正则表达式等领域）。
  2. 一些重复出现的问题可以用一种简单的语言来进行表达。
  3. 一个语言的文法较为简单.
  4. 当执行效率不是关键和主要关心的问题时可考虑解释器模式（注：高效的解释器通常不是通过直接解释抽象语法树来实现的，而是需要将它们转换成其他形式，使用解释器模式的执行效率并不高。）

eg:

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)
    {
        this->left = left;
        this->right = right;
    }
    int interpreter(Context context)
    {
        return this->left->interpreter(context) + this->right->interpreter(context);
    }
};

class SubtractNonterminalExpression:public AbstractExpression
{
private :
    AbstractExpression *left;
    AbstractExpression *right;
public:
    SubtractNonterminalExpression(AbstractExpression *left, AbstractExpression *right)
    {
        this->left = left;
        this->right = right;
    }
    int interpreter(Context context)
    {
        return this->left->interpreter(context) - this->right->interpreter(context);
    }
};

class TerminalExpression :public AbstractExpression
{
private:
    int i;
public:
    TerminalExpression(int i)
    {
        this->i = i;
    }
    int interpreter(Context context)
    {
        return this->i;
    }
};

//--------------------------------------------------
//use
    //a-b+c
    cout<<"解释器模式:a-b+c"<<endl;
    Context context;
    context.addValue("a",7);
    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<< addValue->interpreter(context)<<endl;