C++设计模式-解释器模式_c++解释器

目录

基本概念

代码与实例

基本概念

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

如果一种特定类型的问题发生的频率足够高，那么可能就值得将该问题的各种实例表述为一个简单语言中的句子。这样的就可以构建成一个解释器，该解释器通过解释这些句子来解决问题。

UML图如下（此图来源于大话设计模式）

代码与实例

程序运行截图如下：

Head.h

#ifndef HEAD_H
#define HEAD_H
 
#include <iostream>
#include <string>
using namespace std;
 
class Context;
 
//AbstractExpression作为接口为抽象语法树的所有结点共享
class AbstractExpression{
	
public:
	virtual void interpret(Context *context) = 0;
	virtual ~AbstractExpression(){}
};
 
//TerminalExpression（终结符号表达式）实现与文法中的终结符号相关联的解释操作。实现抽象表达式中所要求的接口，
//主要是一个interpret()方法，文法中每一个终结符号都有一个具体终结表达式与之对应
class TerminalExpression: public AbstractExpression{
 
public:
	void interpret(Context *context);
	~TerminalExpression();
};
 
//NonterminalExpression非终结符号表达式
class NonterminalExpression: public AbstractExpression{
 
public:
	void interpret(Context *context);
	~NonterminalExpression();
};
 
class Context{
 
public:
	string getInput();
	string getOutput();
	void setInput(const string &input);
	void setOutput(const string &output);
	~Context();
 
private:
	string m_input;
	string m_output;
};
 
 
#endif	// HEAD_H

Head.cpp

#include "Head.h"
 
void TerminalExpression::interpret(Context *context)
{
	cout << "终端解释器" << endl;
}
 
TerminalExpression::~TerminalExpression()
{
	cout << "TerminalExpression::~TerminalExpression()" << endl;
}
 
void NonterminalExpression::interpret(Context *context)
{
	cout << "非终端解释器" << endl;
}
 
NonterminalExpression::~NonterminalExpression()
{
	cout << "NonterminalExpression::~NonterminalExpression()" << endl;
}
 
std::string Context::getInput()
{
	return m_input;
}
 
std::string Context::getOutput()
{
	return m_output;
}
 
void Context::setInput(const string &input)
{
	m_input = input;
}
 
void Context::setOutput(const string &output)
{
	m_output = output;
}
 
Context::~Context()
{
	cout << "Context::~Context()" << endl;
}

main.cpp

#include "Head.h"
#include <list>
#include <algorithm>
 
 
void deleteExpress(AbstractExpression *expression){
 
	delete expression;
}
 
int main(int *argc, int *argv){
 
	Context *context = new Context;
 
	list<AbstractExpression*> listExpress;
	listExpress.push_back(new TerminalExpression);
	listExpress.push_back(new NonterminalExpression);
	listExpress.push_back(new TerminalExpression);
	listExpress.push_back(new NonterminalExpression);
 
	for(list<AbstractExpression*>::iterator it = listExpress.begin(); it != listExpress.end(); it++){
		
		(*it)->interpret(context);
	}
 
	for_each(listExpress.begin(), listExpress.end(), deleteExpress);
	listExpress.clear();
	delete context;
 
	getchar();
	return 0;
}