Interpreter模式

Interpreter模式提供了一个实现语法解释器的框架

Context.h

//Context.h
#ifndef _CONTEXT_H_
#define _CONTEXT_H_

class Context
{
public:
	Context();
	~Context();
protected:
private:
};
#endif //~_CONTEXT_H_

Context.cpp

//Context.cpp
#include "Context.h"
Context::Context()
{

}
Context::~Context()
{

}

Interpreter.h

//Interpret.h
#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_

Interpreter.cpp

//interpret.cpp
#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 = 0; i < _times ; i++)
	{
		this->_expression->Interpret(c);
	}
}

main.cpp

#include "Context.h"
#include "Interpret.h"

#include <iostream>
using namespace std;

int main(){
	Context* c = new Context();

	AbstractExpression* te = new TerminalExpression("hello");
	AbstractExpression* nte = new NonterminalExpression(te,2);
	nte->Interpret(*c);

    return 0;
}