解释器设计模式-yiteyi-C++库

解释器设计模式就是其中之一 关于行为的 设计模式。解释器模式用于定义语言的语法表示，并提供一个解释器来处理该语法。

null

该模式涉及实现一个表达式接口，该接口告诉用户如何解释特定的上下文。该模式用于SQL解析、符号处理引擎等。
此模式在表达式的层次结构上执行。这里的每个表达式都是终端或非终端。
解释器设计模式的树结构与复合设计模式定义的树结构有些相似，终端表达式是叶对象，非终端表达式是复合的。
树包含要计算的表达式，通常由解析器生成。解析器本身不是解释器模式的一部分。

例如：下面是表达式的层次结构 “+ – 9 8 7” :

实现解释器模式

UML图解释器设计模式

设计组件

抽象表达 （Expression）：声明一个Expression（）操作，AST中的所有节点（终端和非终端）都将重写该操作。
终末加压 （NumberExpression）：对终端表达式执行EXPLATE（）操作。
非终结符表达式 （AdditionExpression、减法Expression和乘法Expression）：对所有非终端表达式执行expression（）操作。
上下文 （字符串）：包含对解释器全局的信息。必须解释和解析这个带有后缀符号的字符串表达式。
客户（ExpressionParser）：构建（或提供）由TerminalExpression和非TerminalExpression组装而成的AST。客户端调用explorate（）操作。

我们来看一个解释器设计模式的例子。

                     // Expression interface used to                   
                     // check the interpreter.                   
                     interface                               Expression                   
                     {                   
                                         boolean                               interpreter(String con);                   
                     }                   
                             
                     // TerminalExpression class implementing                   
                     // the above interface. This interpreter                   
                     // just check if the data is same as the                   
                     // interpreter data.                   
                     class                               TerminalExpression                               implements                               Expression                   
                     {                   
                                         String data;                   
                             
                                         public                               TerminalExpression(String data)                   
                                         {                   
                                         this                               .data = data;                   
                                         }                   
                             
                                         public                               boolean                               interpreter(String con)                   
                                         {                   
                                         if                               (con.contains(data))                   
                                         {                   
                                         return                               true                               ;                   
                                         }                   
                                         else                   
                                         {                   
                                         return                               false                               ;                   
                                         }                   
                                         }                   
                     }                   
                     // OrExpression class implementing                   
                     // the above interface. This interpreter                   
                     // just returns the or condition of the                   
                     // data is same as the interpreter data.                   
                     class                               OrExpression                               implements                               Expression                   
                     {                   
                                         Expression expr1;                   
                                         Expression expr2;                   
                             
                                         public                               OrExpression(Expression expr1, Expression expr2)                   
                                         {                   
                                         this                               .expr1 = expr1;                   
                                         this                               .expr2 = expr2;                   
                                         }                   
                                         public                               boolean                               interpreter(String con)                   
                                         {                   
                                         return                               expr1.interpreter(con) || expr2.interpreter(con);                   
                                         }                   
                     }                   
                             
                     // AndExpression class implementing                   
                     // the above interface. This interpreter                   
                     // just returns the And condition of the                   
                     // data is same as the interpreter data.                   
                     class                               AndExpression                               implements                               Expression                   
                     {                   
                                         Expression expr1;                   
                                         Expression expr2;                   
                             
                                         public                               AndExpression(Expression expr1, Expression expr2)                   
                                         {                   
                                         this                               .expr1 = expr1;                   
                                         this                               .expr2 = expr2;                   
                                         }                   
                                         public                               boolean                               interpreter(String con)                   
                                         {                   
                                         return                               expr1.interpreter(con) && expr2.interpreter(con);                   
                                         }                   
                     }                   
                             
                     // Driver class                   
                     class                               InterpreterPattern                   
                     {                   
                             
                                         public                               static                               void                               main(String[] args)                   
                                         {                   
                                         Expression person1 =                               new                               TerminalExpression(                               "Kushagra"                               );                   
                                         Expression person2 =                               new                               TerminalExpression(                               "Lokesh"                               );                   
                                         Expression isSingle =                               new                               OrExpression(person1, person2);                   
                             
                                         Expression vikram =                               new                               TerminalExpression(                               "Vikram"                               );                   
                                         Expression committed =                               new                               TerminalExpression(                               "Committed"                               );                   
                                         Expression isCommitted =                               new                               AndExpression(vikram, committed);                   
                             
                                         System.out.println(isSingle.interpreter(                               "Kushagra"                               ));                   
                                         System.out.println(isSingle.interpreter(                               "Lokesh"                               ));                   
                                         System.out.println(isSingle.interpreter(                               "Achint"                               ));                   
                             
                                         System.out.println(isCommitted.interpreter(                               "Committed, Vikram"                               ));                   
                                         System.out.println(isCommitted.interpreter(                               "Single, Vikram"                               ));                   
                             
                                         }                   
                     }                   