设计模式笔记--行为型模式-之三 解释器

 

意图：

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

适用性:

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

效果：

1易于改变和扩展文法 该模式使用类来表示文法规则，可使用继承来改变或扩展文法

2易于实现文法 定义抽象语法树中各个节点的类大体类似，这些类易于直接编写

3 复杂的文法难以维护

4增加了新的解释表达式的方法

实现：

1创建抽象语法树 抽象语法树可用一个表驱动的语法分析程序来生成，也可由手写，或直接由Client提供

2定义解释操作 不一定在表达式中定义解释操作，若要经常创建一种新的解释器，那么使用Visitor模式将解释放入一个独立的访问者对象

3与Flyweight模式共享终结符 在一些文法中，一个句子可能多次出现同一个终结符。此时最好共享那个符号的单个拷贝。

Interpreter.h

1. class Context;
2. class VariableExp;
3. #define MAX_NUM 30
4. class BooleanExp
5. {
6. public:
7.     BooleanExp();
8.     virtual  ~BooleanExp();
9.     virtual bool Evaluate(Context&) = 0;
10.     virtual BooleanExp* Replace(const char*,BooleanExp&) = 0;
11.     virtual BooleanExp* Copy() const = 0;
12. };
13. class Context
14. {
15. public:
16.     Context();
17.     ~Context();
18.     bool Lookup(const char*) const;
19.     void Assign(VariableExp* x,bool y);
20. private:
21.     char* _name[MAX_NUM];
22.     bool  _value[MAX_NUM];
24. };
26. class VariableExp : public BooleanExp
27. {
28. public:
29.     VariableExp(const char*);
30.     virtual ~VariableExp();
31.     virtual bool Evaluate(Context&);
32.     virtual BooleanExp* Replace(const char*,BooleanExp&);
33.     virtual BooleanExp* Copy() const;
34.     char* getname() const {return _name;}
35. private:
36.     char* _name;
37. };
39. class AndExp:public BooleanExp
40. {
41. public:
42.     AndExp(BooleanExp*,BooleanExp*);
43.     virtual ~AndExp();
44.     virtual bool Evaluate(Context&);
45.     virtual BooleanExp* Replace(const char*,BooleanExp&);
46.     virtual BooleanExp* Copy() const;
47. private:
48.     BooleanExp* _operand1;
49.     BooleanExp* _operand2;
50. };
52. class OrExp: public BooleanExp
53. {
54. public:
55.     OrExp(BooleanExp*,BooleanExp*);
56.     virtual  ~OrExp();
57.     virtual bool Evaluate(Context&);
58.     virtual BooleanExp* Replace(const char*,BooleanExp&);
59.     virtual BooleanExp* Copy() const;
60. private:
61.     BooleanExp* _operand1;
62.     BooleanExp* _operand2;
63. };

Interpreter.cpp

1. #include "Interpreter.h"
2. #include <iostream>
3. #include <string>
4. using namespace std;
5. VariableExp::VariableExp(const char* name):BooleanExp()
6. {
7.     cout<<"A variableexp is created"<<endl;
8.     _name = strdup(name);
9. }
10. VariableExp::~VariableExp()
11. {
12.     cout<<"A variableexp id destroyed"<<endl;
13. }
14. bool VariableExp::Evaluate(Context& aContext)
15. {
16.     return aContext.Lookup(_name);
17. }
19. BooleanExp* VariableExp::Copy() const
20. {
21.     return new VariableExp(_name);
22. }
23. BooleanExp* VariableExp::Replace(const char* name,BooleanExp& exp)
24. {
25.     if (strcmp(name,_name) == 0)
26.     {
27.         return exp.Copy();
28.     }
29.     else
30.     {
31.         return new VariableExp(_name);
32.     }
33. }
34. AndExp::AndExp(BooleanExp* op1,BooleanExp* op2)
35. {
36.     _operand1 = op1;
37.     _operand2 = op2;
38.     cout<<"An And Exp is created"<<endl;
39. }
40. AndExp::~AndExp()
41. {
42.     cout<<"An Or Exp is destroyed"<<endl;
43. }
44. bool AndExp::Evaluate(Context& aContext)
45. {
46.     return _operand1->Evaluate(aContext)&
47.            _operand2->Evaluate(aContext);
48. }
50. BooleanExp* AndExp::Copy() const
51. {
52.     return new AndExp(_operand1->Copy(), _operand2->Copy());
53. }
55. BooleanExp* AndExp::Replace(const char* name,BooleanExp& exp)
56. {
57.     return new AndExp(_operand1->Replace(name,exp),
58.                       _operand2->Replace(name,exp)
59.                       );
60. }
61. OrExp::OrExp(BooleanExp* op1,BooleanExp* op2)
62. {
63.     _operand1 = op1;
64.     _operand2 = op2;
65.     cout<<"An Or operator is created"<<endl;
66. }
68. OrExp::~OrExp()
69. {
70.     cout<<"An Or operator is destroyed"<<endl;
71. }
73. bool OrExp::Evaluate(Context& aContext)
74. {
75.     return (_operand1->Evaluate(aContext))||
76.           ( _operand2->Evaluate(aContext));
77. }
78. BooleanExp* OrExp::Copy() const
79. {
80.     return new OrExp(_operand1->Copy(),_operand2->Copy());
81. }
83. BooleanExp* OrExp::Replace(const char* name,BooleanExp& exp)
84. {
85.     return new OrExp(_operand1->Replace(name,exp),
86.                       _operand2->Replace(name,exp)
87.                       );
88. }
89. BooleanExp::BooleanExp()
90. {
91.     cout<< "A BooleanExp is created."<<endl;
92. }
93. BooleanExp::~BooleanExp()
94. {
95.     cout<< "A BooleanExp is destoryed."<<endl;
96. }
97. Context::Context()
98. {
99.     for(int i=0;i<MAX_NUM;i++)
100.     {
101.         _name[i]=0;
102.         _value[i]= false;
103.     }
104. }
105. Context::~Context()
106. {
107.     //delete _name;
108.     cout<<"A context is destroyed"<<endl;
109. }
110. bool Context::Lookup(const char* X) const
111. {
112.     for (int i =0 ;i<MAX_NUM;i ++)
113.     {
114.         if (strcmp (X,_name[i])==0)
115.             return _value[i];
116.     }
117.     return false;
118. }
119. void Context::Assign(VariableExp* x,bool z)
120. {
121.     int i;
122.     for (i =0; i<MAX_NUM&&(_name[i]!=0);i ++)
123.     {
124.         if (strcmp (x->getname(),_name[i])==0)
125.              _value[i] = z;
126.     }
128.     if (i<MAX_NUM) 
129.     {
130.         _name[i]=strdup(x->getname());
131.         _value[i]=z;
132.     }
133. }

main.cpp

1. #include <iostream>
2. #include "Interpreter.h"
3. using namespace std;
4. int main()
5. {
6.     BooleanExp* expression1;
7.     BooleanExp* expression2;
8.     Context context;
9.     VariableExp* x = new VariableExp("X");
10.     VariableExp* y = new VariableExp("Y");
11.     expression1 = new AndExp(x,y);
12.     expression2 = new OrExp(x,y);
13.     context.Assign(x,false);
14.     context.Assign(y,true);
15.     bool result1 = expression1->Evaluate(context);
16.     bool result2 = expression2->Evaluate(context);
18.     cout<<"The result1 is " << result1<<endl;
19.     cout<<"The result2 is " << result2<<endl;
20.     delete expression1;
21.     delete expression2;
22.     delete x;
23.     delete y;
24. //  Context* a = new Context;
25. //delete a;
27.     return 0;
28. }