领域规则模式之Interpreter（解析器模式） | C++

一、领域规则模式之Interpreter（解析器模式）

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

//实例
#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 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);
    }
}
//加法运算
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);
    }
}

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"
    map<char,int> var;
    var.insert(make_pair('a',5));
    var.insert(make_pair('b',3));
    var.insert(make_pair('c',2));
    var.insert(make_pair('d',1));
    Expression* expression=analyse(expStr);
    int result=expression->interpreter(var);
    cout<<result<<endl;
    release(expression);
    return 0;
}

1.模式定义

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

2.要点总结

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

3、结构