DesignPatterns_Interpreter

最新推荐文章于 2015-05-21 22:19:59 发布

头像是我的偶像

最新推荐文章于 2015-05-21 22:19:59 发布

阅读量453

点赞数

分类专栏： DesignPatterns

本文链接：https://blog.csdn.net/u013547361/article/details/45719297

版权

DesignPatterns 专栏收录该内容

22 篇文章 0 订阅

订阅专栏

///
// Interpreter pattern
// - Given a language, define a represention for its grammar along with an interpreter
//   that uses the representation to interpret sentences in the language.
///
#include 
   
   
    
    
#include 
    
    
using namespace std;

// forward declaraction
class VariableExp;

// Context
// - contains information that's global to the interpreter
class Context
{
public:
	bool Lookup(char *name) const;
	void Assign(VariableExp *exp, bool b);

private:
	map
     
     
      
       _mapping;
};

// AbstractExpression
// - declares an abstract Interpret operation that is common to all nodes in the
//   abstract syntax tree.
class BooleanExp
{
public:
	virtual ~BooleanExp() { }
	virtual bool Evaluate(Context &c) = 0;
};

// TerminalExpression
// - implements an Interpret operation associated with terminal symbols in the
//   grammar.
// - an instance is required for every terminal symbol in a sentence.
class VariableExp : public BooleanExp
{
public:
	VariableExp(char *name) : _name(name) { }

	virtual bool Evaluate(Context &aContext)
	{
		return aContext.Lookup(_name);
	}

	const char *GetName()
	{
		return _name;
	}

private:
	char *_name;
};


bool Context::Lookup(char *name) const
{
	for (map
      
      
       
       ::const_iterator map_it = _mapping.begin(); 
		map_it != _mapping.end(); ++map_it)
	{
		if (strcmp(map_it->first->GetName(), name) == 0)
		{
			return map_it->second;
		}
	}
}

void Context::Assign(VariableExp *exp, bool b)
{
	_mapping.insert(std::pair
       
       
         (exp, b)); } // NonterminalExpression // - one such class is required for every rule R::=R1R2...Rn in the grammar. // - maintains instance variables of type AbstractExpression for each of the // symbols R1 through Rn. // - implements an Interpret operation for nonterminal symbols in the grammer. // Interpret typically calls itself recursively on the variables representing // R1 through Rn. class AndExp : public BooleanExp { public: AndExp(BooleanExp *op1, BooleanExp *op2) : _operand1(op1), _operand2(op2) { } virtual bool Evaluate(Context &aContext) { return _operand1->Evaluate(aContext) && _operand2->Evaluate(aContext); } private: BooleanExp *_operand1; BooleanExp *_operand2; }; class OrExp : public BooleanExp { public: OrExp(BooleanExp *op1, BooleanExp *op2) : _operand1(op1), _operand2(op2) { } virtual bool Evaluate(Context &aContext) { return _operand1->Evaluate(aContext) || _operand2->Evaluate(aContext); } private: BooleanExp *_operand1; BooleanExp *_operand2; }; class NotExp : public BooleanExp { public: NotExp(BooleanExp *op) : _operand(op) { } virtual bool Evaluate(Context &aContext) { return ~_operand->Evaluate(aContext); } private: BooleanExp *_operand; }; // Client // - builds(or is given) an abstract syntax tree representing a particular // sentence in the language that the grammar defines. The abstract syntax // tree is assembled from instance fo the NonterminalExpression and // TerminalExpression classes. // - invokes the Interpret operation. int main() { // VariableExp represents a named variable. VariableExp *x = new VariableExp("X"); VariableExp *y = new VariableExp("Y"); // boolean expression (x and y) or (x and (not y)) BooleanExp *expression = new OrExp( new AndExp(x, y), new AndExp(x, new NotExp(y)) ); Context context; context.Assign(x, true); context.Assign(y, false); bool result = expression->Evaluate(context); return 0; }