Interpreter Pattern

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

2.Interpreter模式结构图

3.实现

 #ifndef _CONTEXT_H_
 #define _CONTEXT_H_

 class Context
 {
 public:
     Context();
     ~Context();
 protected:
 private:
 };

 #endif

Context.h

 #include "Context.h"

 Context::Context()
 {

 }
 Context::~Context()
 {

 }

Context.cpp

 #ifndef _INTERPRET_H_
 #define _INTERPRET_H_

 #include "Context.h"
 #include <string>
 using namespace std;

 class AbstractExpression
 {
 public:
     virtual ~AbstractExpression();
     virtual void Interpret(const Context& c);

 protected:
     AbstractExpression();
 private:
 };

 class TerminalExpression:public AbstractExpression
 {
 public:
     TerminalExpression(const string& statement);
     ~ TerminalExpression();
     void Interpret(const Context& c);

 protected:
 private:
     string _statement;
 };

 class NonterminalExpression:public AbstractExpression
 {
 public:
     NonterminalExpression(AbstractExpression* expression,int times);
     ~ NonterminalExpression();
     void Interpret(const Context& c);
 protected:
 private:
     AbstractExpression* _expression;
     int _times;
 };

 #endif

Interpret.h

 #include "Interpret.h"
 #include <iostream>
 using namespace std;

 AbstractExpression::AbstractExpression()
 {

 }
 AbstractExpression::~AbstractExpression()
 {

 }
 void AbstractExpression::Interpret(const Context& c)
 {

 }
 TerminalExpression::TerminalExpression(const string& statement)
 {
     this->_statement = statement;
 }
 TerminalExpression::~TerminalExpression()
 {

 }
 void TerminalExpression::Interpret(const Context& c)
 {
     cout<<this->_statement<<" TerminalExpression"<<endl;
 }
 NonterminalExpression::NonterminalExpression(AbstractExpression* expression,int times)
 {
     this->_expression = expression;
     this->_times = times;
 }
 NonterminalExpression::~NonterminalExpression()
 {

 }
 void NonterminalExpression::Interpret(const Context& c)
 {
     for (int i = ; i < _times ; i++)
     {
         this->_expression->Interpret(c);
     }
 }

Interpret.cpp

 #include "Context.h"
 #include "Interpret.h"
 #include <iostream>
 using namespace std;

 int main(int argc,char* argv[])
 {
     Context* c = new Context();
     AbstractExpression* te = new TerminalExpression("hello");
     AbstractExpression* nte = new NonterminalExpression(te,);
     nte->Interpret(*c);

     return ;
 }

main.cpp