解释器模式
【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 */
（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 }
【3】应用
通常当一个语言需要解释执行，并且你可以将语言中的句子表示成为一个抽象的语法树时，可以使用解释器模式。
Good Good Study, Day Day Up.
顺序 选择 循环 总结
