zoukankan html css js c++ java

Interpreter Pattern

1.Interpreter模式的目的就是提供一个一门定义语言的语法表示的解释器，然后通过这个解释器来解释语言中的句子。

2.Interpreter模式结构图

3.实现

 1 #ifndef _CONTEXT_H_ 
 2 #define _CONTEXT_H_
 3 
 4 class Context 
 5 { 
 6 public:
 7     Context();
 8     ~Context();
 9 protected:
10 private:
11 };
12 
13 #endif

Context.h

 1 #include "Context.h"
 2 
 3 Context::Context() 
 4 {
 5 
 6 }
 7 Context::~Context() 
 8 {
 9 
10 }

Context.cpp

 1 #ifndef _INTERPRET_H_
 2 #define _INTERPRET_H_
 3 
 4 #include "Context.h" 
 5 #include <string> 
 6 using namespace std;
 7 
 8 class AbstractExpression 
 9 { 
10 public: 
11     virtual ~AbstractExpression();
12     virtual void Interpret(const Context& c);
13 
14 protected: 
15     AbstractExpression();
16 private:
17 };
18 
19 class TerminalExpression:public AbstractExpression 
20 {
21 public: 
22     TerminalExpression(const string& statement);
23     ~ TerminalExpression();
24     void Interpret(const Context& c);
25 
26 protected:
27 private: 
28     string _statement; 
29 };
30 
31 class NonterminalExpression:public AbstractExpression 
32 { 
33 public:
34     NonterminalExpression(AbstractExpression* expression,int times);
35     ~ NonterminalExpression();
36     void Interpret(const Context& c);
37 protected:
38 private: 
39     AbstractExpression* _expression;
40     int _times; 
41 };
42 
43 #endif

Interpret.h

 1 #include "Interpret.h" 
 2 #include <iostream> 
 3 using namespace std;
 4 
 5 AbstractExpression::AbstractExpression() 
 6 {
 7 
 8 }
 9 AbstractExpression::~AbstractExpression()
10 {
11 
12 }
13 void AbstractExpression::Interpret(const Context& c) 
14 {
15 
16 }
17 TerminalExpression::TerminalExpression(const string& statement)
18 { 
19     this->_statement = statement; 
20 }
21 TerminalExpression::~TerminalExpression()
22 {
23 
24 }
25 void TerminalExpression::Interpret(const Context& c) 
26 { 
27     cout<<this->_statement<<" TerminalExpression"<<endl;
28 }
29 NonterminalExpression::NonterminalExpression(AbstractExpression* expression,int times)
30 { 
31     this->_expression = expression;
32     this->_times = times; 
33 }
34 NonterminalExpression::~NonterminalExpression() 
35 {
36 
37 }
38 void NonterminalExpression::Interpret(const Context& c) 
39 { 
40     for (int i = 0; i < _times ; i++) 
41     { 
42         this->_expression->Interpret(c); 
43     } 
44 }

Interpret.cpp

 1 #include "Context.h" 
 2 #include "Interpret.h" 
 3 #include <iostream> 
 4 using namespace std;
 5 
 6 int main(int argc,char* argv[])
 7 {
 8     Context* c = new Context();
 9     AbstractExpression* te = new TerminalExpression("hello");
10     AbstractExpression* nte = new NonterminalExpression(te,2);
11     nte->Interpret(*c);
12 
13     return 0; 
14 }

main.cpp

查看全文

相关阅读:
面向对象设计原则之接口隔离原则
 面向对象设计原则之开闭原则
 [OOD]违反里氏替换原则的解决方案
 错误程序
 error: ‘for’ loop initial declarations are only allowed in C99 mode
函数模板
 查找
 队列类模板
 栈类模板
 单链表的结点类模板

原文地址：https://www.cnblogs.com/programmer-wfq/p/4673752.html