[设计模式] 设计模式课程（二十二）--解析器模式

• 在软件构建过程中，如果某一特定领域的问题比较复杂，类似的结构不断重复出现，如果使用普通的编程方式来实现将面临非常频繁的变化
• 在这种情况下，将特定领域的问题表达为某种语法规则下的句子，然后构建一个解析器来解释这样的句子，从而解决问题
• GoF：给定一个语言，定义它的文法的一种表示，并定义一种解释器，这个解释器使用该表示来解释语言中的句子
• Interpreter模式的应用场合：业务规则频繁变化，且类似的结构不断重复出现，并容易抽象为语法规则的问题（如将大写数字转换为数字）
• 使用Interpreter来表示文法规则，从而可使用面向对象技巧来方便地“扩展”文法
• 适用于简单的文法表示，对于复杂的文法表示，Interpreter会产生比较大的层次结构，需要借助于语法分析生成器这样的标准工具
• 适合小而简单的问题，问题复杂就不好用，实际开发中使用有限

     

 

 Interpreter.cpp

  1 #include <iostream>
  2 #include <map>
  3 #include <stack>
  4 
  5 using namespace std;
  6 
  7 class Expression {
  8 public:
  9     virtual int interpreter(map<char, int> var)=0;
 10     virtual ~Expression(){}
 11 };
 12 
 13 //变量表达式
 14 class VarExpression: public Expression {
 15     
 16     char key;
 17     
 18 public:
 19     VarExpression(const char& key)
 20     {
 21         this->key = key;
 22     }
 23     
 24     int interpreter(map<char, int> var) override {
 25         return var[key];
 26     }
 27     
 28 };
 29 
 30 //符号表达式
 31 class SymbolExpression : public Expression { 
 32     
 33     // 运算符左右两个参数
 34 protected:
 35     Expression* left;
 36     Expression* right;
 37     
 38 public:
 39     SymbolExpression( Expression* left,  Expression* right):
 40         left(left),right(right){
 41         
 42     }
 43     
 44 };
 45 
 46 //加法运算
 47 class AddExpression : public SymbolExpression {
 48     
 49 public:
 50     AddExpression(Expression* left, Expression* right):
 51         SymbolExpression(left,right){
 52         
 53     }
 54     int interpreter(map<char, int> var) override {
 55         return left->interpreter(var) + right->interpreter(var);
 56     }
 57     
 58 };
 59 
 60 //减法运算
 61 class SubExpression : public SymbolExpression {
 62     
 63 public:
 64     SubExpression(Expression* left, Expression* right):
 65         SymbolExpression(left,right){
 66         
 67     }
 68     int interpreter(map<char, int> var) override {
 69         return left->interpreter(var) - right->interpreter(var);
 70     }
 71     
 72 };
 73 
 74 Expression*  analyse(string expStr) {
 75     
 76     stack<Expression*> expStack;
 77     Expression* left = nullptr;
 78     Expression* right = nullptr;
 79     for(int i=0; i<expStr.size(); i++)
 80     {
 81         switch(expStr[i])
 82         {
 83             case '+':
 84                 // 加法运算
 85                 left = expStack.top();
 86                 right = new VarExpression(expStr[++i]);
 87                 expStack.push(new AddExpression(left, right));
 88                 break;
 89             case '-':
 90                 // 减法运算
 91                 left = expStack.top();
 92                 right = new VarExpression(expStr[++i]);
 93                 expStack.push(new SubExpression(left, right));
 94                 break;
 95             default:
 96                 // 变量表达式
 97                 expStack.push(new VarExpression(expStr[i]));
 98         }
 99     }
100    
101     Expression* expression = expStack.top();
102 
103     return expression;
104 }
105 
106 void release(Expression* expression){
107     
108     //释放表达式树的节点内存...
109 }
110 
111 int main(int argc, const char * argv[]) {
112     
113     string expStr = "a+b-c+d-e";
114     map<char, int> var;
115     var.insert(make_pair('a',5));
116     var.insert(make_pair('b',2));
117     var.insert(make_pair('c',1));
118     var.insert(make_pair('d',6));
119     var.insert(make_pair('e',10));
120     
121     Expression* expression= analyse(expStr);
122      
123     int result=expression->interpreter(var);
124     
125     cout<<result<<endl;
126     
127     release(expression);
128     
129     return 0;
130 }

View Code