学习记录：《C++设计模式——李建忠主讲》7.“领域规则”模式

领域规则模式：在特定领域中，某些变化虽然频繁，但可以抽象为某种规则。这时候，结合特定的领域，将问题抽象为语法规则，从而给出该领域下的一般性解决方案。

典型模式：解释器模式（Interpreter）。

解释器模式

1.动机

在软件构建过程中，如果某一特定领域内的问题比较复杂，类似的结构不断重复出现，如果使用普通的编程方式来实现将面临非常频繁的变化。

2.作用

将特定领域问题表达为某种语法规则下的句子，然后构建一个解释器来解释这样的句子。

3.定义

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

4.代码

//运用解释器模式后代码
class Expression {
public:
    virtual int interpreter(map<char, int> var)=0;
    virtual ~Expression(){}
};
//变量表达式
class VarExpression: public Expression {
    char key;   
public:
    VarExpression(const char& 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):
        SymbolExpression(left,right){

    }
    int interpreter(map<char, int> var) override {
        return left->interpreter(var) + right->interpreter(var);
    }
};
//减法运算
class SubExpression : public SymbolExpression {
public:
    SubExpression(Expression* left, Expression* right):
        SymbolExpression(left,right){
        
    }
    int interpreter(map<char, int> var) override {
        return left->interpreter(var) - right->interpreter(var);
    }
};
Expression*  analyse(string expStr) {
    stack<Expression*> expStack;
    Expression* left = nullptr;
    Expression* right = nullptr;
    for(int i=0; i<expStr.size(); i++)
    {
        switch(expStr[i])
        {
            case '+':
                // 加法运算
                left = expStack.top();
                right = new VarExpression(expStr[++i]);
                expStack.push(new AddExpression(left, right));
                break;
            case '-':
                // 减法运算
                left = expStack.top();
                right = new VarExpression(expStr[++i]);
                expStack.push(new SubExpression(left, right));
                break;
            default:
                // 变量表达式
                expStack.push(new VarExpression(expStr[i]));
        }
    }
    Expression* expression = expStack.top();
    return expression;
}
void release(Expression* expression){  
    //释放表达式树的节点内存...
}
int main(int argc, const char * argv[]) {
    string expStr = "a+b-c+d-e";
    map<char, int> var;
    var.insert(make_pair('a',5));
    var.insert(make_pair('b',2));
    var.insert(make_pair('c',1));
    var.insert(make_pair('d',6));
    var.insert(make_pair('e',10));
    Expression* expression= analyse(expStr);
    int result=expression->interpreter(var);
    cout<<result<<endl;
    release(expression);
    return 0;
}
        pState->Operation1();
        pState = pState->pNext;
        //...
    }
    void Operation2(){
        //...
        pState->Operation2();
        pState = pState->pNext;
        //...
    }
    void Operation3(){
        //...
        pState->Operation3();
        pState = pState->pNext;
        //...
    }
};

5.结构

其中，

        1.AbstractExpression（抽象表达式 如）：声明一个抽象的解释操作，这个接口为抽象语法树中所有的节点所共享；

        2.TerminalExpression（终结符表达式 如）：实现与文法中的终结符相关联的解释操作；一个句子中的每个终结符需要该类的一个实例。

        3.NonterminalExpression（非终结符表达式）：对文法中的每一条规则R：：=R1R2…R3都需要一个NonterminalExpression类；为从R1到Rn的每个符号都维护一个AbstractExpression类型的实例变量；为文法中的非终结符实现解释操作，解释一般要递归调用表示R1到Rn的那些对象的解释操作。

        4.Context（上下文）：包含解释器之外的一些全局信息。

        5.Client（客户）：构建表示该文法定义的语言中一个特定的句子的抽象语法树。该抽象语法树由TerminalExpression和NonterminalExpression的实例装配而成。

6.总结   

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

       2.使用Interpret模式来表示文法规则，从而可以使用面向对象技巧来方便的扩展文法。

       3.Interpret模式比较适合简单的文法表示，对于复杂的文法表示，Interpret模式会产生比较大的类层次结构，需要求助于语法分析器这样的标准工具。