[C++][设计模式][解析器]详细讲解

---

1.动机

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

---

2.模式定义

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

---

3.要点总结

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

---

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() 
  {
      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;
  }