李建忠设计模式之”领域规则“模式

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

典型模式：Interpreter。

解析器模式（Interpreter）

定义

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

——《设计模式》GoF

动机

• 在软件构建过程中，如果某一特定领域的问题比较复杂，类似的结构不断重复出现，如果使用普通的编程方式来实现将面临非常频繁的变化。
• 在这种情况下，将特定领域的问题表达为某种语法规则下的句子，然后构建一个解释器来解释这样的句子，从而达到解决问题的目的。

结构图

代码

#include <iostream>
#include <map>
#include <stack>

using namespace std;
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 AddExpressin : 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 SymbotExpression {
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 VarException(expStr[i]));
    	}
        Exception* exception = expStack.top();
        return exception;
    }
}
void release(Expression* expression){
    //释放表达式树的节点内存。
}

int main(int argc, const char * argv[]) {
    string expStr = "a+b-c+d-e+f";
    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));
    
    Expression* expression = analyse(expStr);
    int result = expression->interpreter(var);
    cout<<result<<endl;
    release(expression);
    return 0;
}

上面表达式可解析为下面的树形结构：

要点

• Interpreter模式的应用场合是Interpreter模式应用中的难点，只有满足“业务规则频繁变化，且类似的结构不断重复出现，并且容易抽象为语法规则的问题”才适合使用Interpreter模式。
• 使用Interpreter模式来表示文法规则，从而可以使用面向对象技巧来方便地“扩展”文法。
• Interpreter模式比较适合简单的文法表示，对于复杂的文法表示，Interperter模式会产生比较大的类层次结构，需要求助于语法分析生成器这样的标准工具。

总结

面向对象的Interpreter模式适合简单的规则表示，对于复杂的文法表示会造成非常庞大的层次结构，产生非常多的虚函数指针，造成性能问题。相对来说，在今天，这种模式应用场景还是比较少了。