1. 解释器模式: 给定一个语言,定义它的文法的一种表示 并 定义一个解释器,这个解释器使用该表示文法 来解释语言中的句子。
如果一种特定类型的问题发生的频率很高,那么可能就值得将该问题的各个实例表述为一个简单语言中的句子,这样就可以构建一个解释器,该解释器通过解释这些句子来解决该问题。
当一个语言需要解释执行,并且你可以将该语言中的句子表示为一个抽象语法树时,可使用解释器模式。
实例:
context.h context.cpp 需要解释的文本内容
#ifndef CONTEXT_H
#define CONTEXT_H
#include <string>
using namespace std;
class Context
{
public:
Context();
string input;
string output;
};
#endif // CONTEXT_H
#include "context.h"
Context::Context()
{
input = "";
output = "";
}
abstractexpression.h abstractexpression.h 抽象解释器,具有统一的解释器接口
#include "context.h"
class AbstractExpression
{
public:
AbstractExpression();
void virtual interpret(Context *context)=0;
};
#endif // ABSTRACTEXPRESSION_H
#include "abstractexpression.h"
AbstractExpression::AbstractExpression()
{
}
terminalexpression.h terminalexpression.cpp 具体的解释器1,方法interpret中应该是对Context的解释。。
#ifndef TERMINALEXPRESSION_H
#define TERMINALEXPRESSION_H
#include "abstractexpression.h"
#include "context.h"
class TerminalExpression : public AbstractExpression
{
public:
TerminalExpression();
void interpret(Context *context);
};
#endif // TERMINALEXPRESSION_H
#include "terminalexpression.h"
#include <iostream>
using namespace std;
TerminalExpression::TerminalExpression()
{
}
void TerminalExpression::interpret(Context* context)
{
cout << "Terminal Expression --> context" << endl;
}
nonterminalexpression.h nonterminalexpression.cpp 具体解释器2
#ifndef NONTERMINALEXPRESSION_H
#define NONTERMINALEXPRESSION_H
#include "abstractexpression.h"
#include "context.h"
class NonterminalExpression : public AbstractExpression
{
public:
NonterminalExpression();
void interpret(Context *context);
};
#endif // NONTERMINALEXPRESSION_H
#include "nonterminalexpression.h"
#include <iostream>
using namespace std;
NonterminalExpression::NonterminalExpression()
{
}
void NonterminalExpression::interpret(Context *context)
{
cout << "Non-Terminal Expression --> context" << endl;
}
main.cpp
#include <iostream>
#include "context.h"
#include "terminalexpression.h"
#include "nonterminalexpression.h"
using namespace std;
int main()
{
cout << "Interpreter test!" << endl;
Context *context = new Context();
AbstractExpression *t = new TerminalExpression();
AbstractExpression *n = new NonterminalExpression();
t->interpret(context);
n->interpret(context);
return 0;
}