设计模式——解析器（parser）

特定领域，某些变化虽然频繁，但是可以抽象为某种规则；结合特定领域，将问题抽象为语法规则，从而给出该领域的一般性解决方案。

interpreter属于"领域规则"模式。

motivation：软件构件过程中，对于某一特定领域的问题比较复杂，类似结构重复出现；可以将特定领域的问题表达为语法规则下的句子，然后使用解释器来解释这样的句子。

key interface or class：

        1. 一定会有个terminal类继承abstractExpression类。

feature： 对规则进行抽像。

structure：

codes:

class Expression{
public:
    virtual int interpreter(map<char,int> var)=0;
    virtual ~Expression(){};
}

//变量表达式
class VarExpression: public Expression
{
    char key;
public:
    VarExpression(const VarExpression & key){
        this->key = key;
    }
    int interpreter(map<char,int> var) override {
        return var[key];
    }
};

//符号表达式
class SymbolExpression: public Expression{
    //运算符左右两个参数
protected:
    Expression* left;
    Expression* right;
public:
    SymbolExpression(Expression* left，Expression* right):
    left(left),right(right)
    { }
};

//加法运算，继承符号表达式
class AddExpression: public SymbolExpression{
public:
    AddExpression(Expression* left，Expression* right):
    left(left),right(right)
    { }
    
    int interpreter(map<char,int> var) override {
        return left->interpreter(var) + right->interpreter(var);
    }
}

//减法运算，继承符号表达式
class SubstractExpression: public SymbolExpression{
public:
    SubstractExpression(Expression* left，Expression* right):
    left(left),right(right)
    { }
    
    int interpreter(map<char,int> var) override {
        return left->interpreter(var) - right->interpreter(var);
    }
}


Expression* analyse(string str){
    stack<Expression*> expStack;
    Expression* left=nullptr;
    Expression* right=nullptr;
    for(inti=0;i<str.size();i++){
        switch(str[i]){
            case '+':
                //加法运算
                left = expStack.top();
                right = new VarExpression(str[++i]);
                expStack.push(new AddExpression(left,right));
                brek;
            case '-':
                //减法运算
                left = expStack.top();
                right = new VarExpression(str[++i]);
                expStack.push(new SubstractExpression(left,right));
                brek;
            default:
                //终结表达式
                expStack.push(new SubstractExpression(left,right));
        }
    }
    Expression* expression = expStack.top();
    return expression;
}

void Release(Expression* expression){
    //释放表达树的节点内存
}


int main(){
    string exp = "a+b-c+d";
    map<char,int> var;
    var.insert(map_pair('a',5));
    var.insert(map_pair('b',1));
    var.insert(map_pair('c',3));
    var.insert(map_pair('d',2));

    Expression* expression = analyse(exp);
    int result = expression->intpreter(var);

    Release(expression)；

}

summary：

1. interpreter的使用场景是其难点，只有满足“业务规则频繁变化，且类似结构不断重复出现，并且容易抽象为语法规则”的问题，才适合使用interpreter模式；

2.使用interpreter模式来表示文法规则，从而可以使用面对对象技巧来方便地“扩展”文法；

3.interpreter模式适合于简单的文法表示，对于复杂的文法表示会产生较大的类层次结构，可以借助于语法分析生成器这类的标准工具。