解释器模式

【1】什么是解释器模式？

解释器模式：拟定一种 “语言”，定义该语言文法的一种表示，并定义一种解释器，这个解释器使用该表示文法来解释语言中的句子。

【2】解释器模式代码示例：

（1）代码示例1：

 1 #include <iostream>
 2 #include <list>
 3 #include <string>
 4 using namespace std;
 5 
 6 class Context;
 7 
 8 class AbstractExpression
 9 {
10 public:
11     virtual void interpret(Context *) = 0;
12 };
13 
14 class TerminalExpression : public AbstractExpression
15 {
16 public:
17     void interpret(Context *context)
18     {
19         cout << "终端解释器" << endl;
20     }
21 };
22 
23 class NonterminalExpression : public AbstractExpression
24 {
25 public:
26     void interpret(Context *context)
27     {
28         cout << "非终端解释器" << endl;
29     }
30 };
31 
32 class Context
33 {
34 public:
35     string input, output;
36 };
37 
38 int main()
39 {
40     Context *context = new Context(); 
41     list<AbstractExpression*>  lt;
42     lt.push_back(new TerminalExpression());
43     lt.push_back(new NonterminalExpression());
44     lt.push_back(new TerminalExpression());
45     lt.push_back(new TerminalExpression());
46     
47     for (list<AbstractExpression*>::iterator iter = lt.begin(); iter != lt.end(); iter++)
48     {
49         (*iter)->interpret(context);
50     }
51     
52     return 0;
53 }
54 // Result:
55 /*
56 终端解释器
57 非终端解释器
58 终端解释器
59 终端解释器
60 */

View Code

（2）代码示例2：

  1 #include <iostream>  
  2 #include <map>  
  3 #include <string>  
  4  
  5 using namespace std;  
  6 
  7 class Context
  8 {
  9 private:
 10     map<string, int> valueMap;
 11 
 12 public:
 13     void addValue(string key,int value)
 14     {       
 15         valueMap.insert(std::pair<string, int>(key, value));   // 插入构建项
 16     }
 17 
 18     int getValue(string key)
 19     {
 20         return valueMap[key]; // 解析值
 21     }
 22 };
 23 
 24 class AbstractExpression
 25 {
 26 public :
 27      virtual int interpreter(Context context) = 0;
 28 };
 29 
 30 class AddNonterminalExpression : public AbstractExpression
 31 {
 32 private :
 33     AbstractExpression *left;
 34     AbstractExpression *right;
 35 
 36 public:
 37     AddNonterminalExpression(AbstractExpression *left, AbstractExpression *right)
 38         : left(left)
 39         , right(right)
 40     {
 41     }
 42 
 43     int interpreter(Context context)
 44     {
 45         return (left->interpreter(context)) + (right->interpreter(context));
 46     }
 47 };
 48 
 49 class SubtractNonterminalExpression : public AbstractExpression
 50 {
 51 private :
 52     AbstractExpression *left;
 53     AbstractExpression *right;
 54 
 55 public:
 56     SubtractNonterminalExpression(AbstractExpression *left, AbstractExpression *right)
 57         : left(left)
 58         , right(right)
 59     {
 60     }
 61 
 62     int interpreter(Context context)
 63     {
 64         return (left->interpreter(context)) - (right->interpreter(context));
 65     }
 66 };
 67 
 68 class TerminalExpression : public AbstractExpression
 69 {
 70 private :
 71     int i;
 72 public :
 73     TerminalExpression(int i) : i(i)
 74     {
 75     }
 76 
 77     int interpreter(Context context)
 78     {
 79         return i;
 80     }
 81 };
 82 
 83 int main()
 84 {  
 85     // a - b + c
 86     Context context;
 87     context.addValue("a", 10);
 88     context.addValue("b", 8);
 89     context.addValue("c", 2);
 90 
 91     SubtractNonterminalExpression *subtractValue = 
 92         new SubtractNonterminalExpression(new TerminalExpression(context.getValue("a")), new TerminalExpression(context.getValue("b")));
 93 
 94     AddNonterminalExpression *addValue = new AddNonterminalExpression(subtractValue, new TerminalExpression(context.getValue("c")));
 95 
 96     cout << subtractValue->interpreter(context);  // 10 - 8 = 2
 97     cout << addValue->interpreter(context);  // 2 + 2 = 4
 98     
 99     return 0;  
100 }

View Code

【3】应用

通常当一个语言需要解释执行，并且你可以将语言中的句子表示成为一个抽象的语法树时，可以使用解释器模式。

Good Good Study, Day Day Up.

顺序选择循环总结