一、描述:
概念:给定一个语言,定义它的文法的一种表示,并定义一个解释器,这个解释器使用该表示来解释语言中的句子。
最简单的例子是表达式运算。
Interpreter 模式典型的结构图为:
Interpreter 模式中,提供了 TerminalExpression 和 NonterminalExpression 两种表达式的解释方式,Context 类用于为解释过程提供一些附加的信息(例如全局的信息)。
二、实例
我的工程目录:
注释:
main:客户
AbstractExpression:表达式接口
TerminalExpression:终结符表达
NonterminalExpression:非终符结表达
Context:用于为解释过程提供一些附加的信息(例如全局的信息)。
代码:
表达式接口 ;AbstractExpression类
AbstractExpression.h
#ifndef __Interpreter__Interpret__
#define __Interpreter__Interpret__
#include <iostream>
#include "Context.h"
#include <string>
using namespace std;
class AbstractExpression
{
public:
virtual ~AbstractExpression();
virtual void Interpret(const Context& c);
protected:
AbstractExpression();
};
#endif /* defined(__Interpreter__Interpret__) */
AbstractExpression.cpp
#include "AbstractExpression.h"
AbstractExpression::AbstractExpression()
{
}
AbstractExpression::~AbstractExpression()
{
}
void AbstractExpression::Interpret(const Context& c)
{
}
终结符表达:TerminalExpression
TerminalExpression.h
#ifndef __Interpreter__TerminalExpression__
#define __Interpreter__TerminalExpression__
#include <iostream>
#include "AbstractExpression.h"
class TerminalExpression:public AbstractExpression
{
public:
TerminalExpression(const string& statement);
~TerminalExpression();
void Interpret(const Context& c);
private:
string _statement;
};
#endif /* defined(__Interpreter__TerminalExpression__) */
TerminalExpression.cpp
#include "TerminalExpression.h"
TerminalExpression::TerminalExpression(const string& statement)
{
this->_statement = statement;
}
TerminalExpression::~TerminalExpression()
{
}
void TerminalExpression::Interpret(const Context& c)
{
cout<<this->_statement<<"TerminalExpression"<<endl;
}
非终符结表达:NonterminalExpression
NonterminalExpression.h
#ifndef __Interpreter__NonterminalExpression__
#define __Interpreter__NonterminalExpression__
#include <iostream>
#include "AbstractExpression.h"
class NonterminalExpression:public AbstractExpression
{
public:
NonterminalExpression(AbstractExpression* expression,int times);
~ NonterminalExpression();
void Interpret(const Context& c);
private:
AbstractExpression* _expression;
int _times;
};
#endif /* defined(__Interpreter__NonterminalExpression__) */
NonterminalExpression.cpp
#include "NonterminalExpression.h"
NonterminalExpression::NonterminalExpression(AbstractExpression* expression,int times)
{
this->_expression = expression;
this->_times = times;
}
NonterminalExpression::~NonterminalExpression()
{
}
void NonterminalExpression::Interpret(const Context& c)
{
for (int i = 0; i < _times ; i++)
{
this->_expression->Interpret(c);
}
}
用于为解释过程提供一些附加的信息(例如全局的信息):Context
Context.h
#ifndef __Interpreter__Context__
#define __Interpreter__Context__
#include <iostream>
class Context
{
public:
Context(){};
~Context(){};
};
#endif /* defined(__Interpreter__Context__) */
客户:main
main.cpp
#include <iostream>
#include "Context.h"
#include "AbstractExpression.h"
#include "TerminalExpression.h"
#include "NonterminalExpression.h"
void DoIt()
{
Context* myContext = new Context();
AbstractExpression* myTerminalExpression = new TerminalExpression("HelloWorld......");
AbstractExpression * myNonterminalExpression = new NonterminalExpression(myTerminalExpression,3);
myNonterminalExpression->Interpret(*myContext);
}
int main(int argc, const char * argv[])
{
DoIt();
// insert code here...
std::cout << "Hello, World!\n";
return 0;
}
结果如下: