动机

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

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

  • 只要你符合这个规则，解析器都可以解析，不管你怎么变换

代码

  1. #include <iostream>
  2. #include <map>
  3. #include <stack>
  4. using namespace std;
  6. //抽象表达式
  7. class Expression {
  8. public:
  9.     virtual int interpreter(map<char, int> var)=0;
  10.     virtual ~Expression(){}
  11. };
  12. //变量表达式（就是这里的叶子结点）
  13. class VarExpression: public Expression {
  14.     char key;
  15. public:
  16.     VarExpression(const char& key)
  17.     {
  18.         this->key = key;
  19.     }
  20.     int interpreter(map<char, int> var) override {
  21.         return var[key];
  22.     }
  23. };
  24. //符号表达式
  25. class SymbolExpression : public Expression {
  26. protected: // 运算符左右两个参数
  27.     Expression* left;
  28.     Expression* right;
  29. public:
  30.     SymbolExpression( Expression* left,  Expression* right):
  31.         left(left),right(right){
  32.     }
  33. };
  34. //加法运算
  35. class AddExpression : public SymbolExpression {
  36. public:
  37.     AddExpression(Expression* left, Expression* right):
  38.         SymbolExpression(left,right){
  39.     }
  40.     int interpreter(map<char, int> var) override {
  41.         return left->interpreter(var) + right->interpreter(var);
  42.     }
  43. };
  44. //减法运算
  45. class SubExpression : public SymbolExpression {
  46. public:
  47.     SubExpression(Expression* left, Expression* right):
  48.         SymbolExpression(left,right){
  49.     }
  50.     int interpreter(map<char, int> var) override {
  51.         return left->interpreter(var) - right->interpreter(var);
  52.     }
  53. };
  55. //将表达式解析成一个语法树
  56. Expression* analyse(string expStr) {
  57.     stack<Expression*> expStack;
  58.     Expression* left = nullptr;
  59.     Expression* right = nullptr;
  60.     for(int i=0; i<expStr.size(); i++)
  61.     {
  62.         switch(expStr[i])
  63.         {
  64.             case '+':
  65.                 // 加法运算
  66.                 left = expStack.top();
  67.                 right = new VarExpression(expStr[++i]);
  68.                 expStack.push(new AddExpression(left, right));
  69.                 break;
  70.             case '-':
  71.                 // 减法运算
  72.                 left = expStack.top();
  73.                 right = new VarExpression(expStr[++i]);
  74.                 expStack.push(new SubExpression(left, right));
  75.                 break;
  76.             default:
  77.                 // 变量表达式
  78.                 expStack.push(new VarExpression(expStr[i]));
  79.         }
  80.     }
  82.     Expression* expression = expStack.top();
  83.     return expression;
  84. }
  86. void release(Expression* expression){
  87.      //释放表达式树的节点内存...
  88. }
  90. void main(int argc, const char * argv[]) {
  91.     string expStr = "a+b-c+d-e";
  92.     map<char, int> var;
  93.     var.insert(make_pair('a',5));
  94.     var.insert(make_pair('b',2));
  95.     var.insert(make_pair('c',1));
  96.     var.insert(make_pair('d',6));
  97.     var.insert(make_pair('e',10));
  99.     //构建一个解析器来解释这个句子
  100.     Expression* expression= analyse(expStr);
  101.       //然后计算
  102.     int result=expression->interpreter(var);
  103.     cout<<result<<endl;
  104.     release(expression);
  105. }

image.png

模式定义

给定一个语言，定义它的文法的一种表示，并定义一种解释器，这个解释器使用该表示来解释语言中的句子。——《设计模式》GoF

结构

image.png

  1. TerminalExpression是叶子结点
  2. NonterminalExpression是非叶子结点，即中间节点

要点总结

要点一

Interpreter模式的应用场合是Interpreter模式应用中的难点
只有满足

  1. 业务规则频繁变化
  2. 且类似的结构不断重复出现
  3. 并且容易抽象为语法规则的问题

才适合使用Interpreter模式

比如，string s1 = "肆仟叁佰伍拾陆";这个也可以抽象出语法，然后使用解析器来处理。

要点二

使用Interpreter模式来表示文法规则，从而可以使用面向对象技巧来方便地“扩展”文法。

要点三

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

  • 复杂的文法，比如SQL语句，解释器模式就会产生很大的类层次结构，而且有相当多的虚函数调用，性能很不好。因此，在现在此设计模式不是很常用。
  • 这时候可以借助语法分析相关的工具，帮助我们完成语法解析，而不用面向对象的形式解决（Interpreter模式）。