我与C++设计模式（二十二）——解释者模式

终于到这里了，长吸一口气，interpreter pattern理解起来感觉跟编译原理挂钩了，我表示编译原理好不熟啊，但是这篇文章值得一看，看完你就懂了。

定义：

Given a language, define a representation for its grammar along with an interpreter that uses the representation to interpret sentences in the language。给定一个语言, 定义它的文法的一种表示，并定义一个解释器，该解释器使用该表示来解释语言中的句子。

类图：

AbstractExpression是解释器的抽象接口，TerminalExpression终结符表达式，实现与文法中的元素相关联的解释操作，通常一个解释器模式中只有一个终结符表达式，但有多个实例，对应不同的终结符。具体到推荐文章中的四则表达式例子中就是加减符号，就是VarExpression类，表达式中的每个终结符都在堆栈中产生了一个VarExpression对象。NonterminalExpression 非终结符表达式，文法中的每条规则（加、减、乘、除）对应于一个非终结表达式，具体到我们的例子就是加减法规则分别对应到AddExpression和SubExpression两个类。非终结符表达式根据逻辑的复杂程度而增加，原则上每个文法规则都对应一个非终结符表达式。Context 环境角色，具体到该例子中是采用HashMap代替。

解释器是一个比较少用的模式，以下为其通用源码，可以作为参考。

代码：

#ifndef _CONTEXT_H__
#define _CONTEXT_H__

class context
{
        public:
                context(){};
                ~context(){};
};
#endif

#ifndef _INTERPRETER_H__
#define _INTERPRETER_H__

#include <string>
using namespace std;

class context;

class abstract_expression
{
        public:
                virtual ~abstract_expression();
                virtual void interpreter(const context&) = 0;

        protected:
                abstract_expression();
};

class terminal_expression:public abstract_expression
{
        public:
                terminal_expression(const string &);
                ~terminal_expression();
                void interpreter(const context &);

        private:
                string _statement;
};

class non_terminal_expression:public abstract_expression
{
        public:
                non_terminal_expression(abstract_expression *,int);
                ~non_terminal_expression();
                void interpreter(const context &);

        private:
                abstract_expression *_expression;
                int _times;
};
#endif

//interpreter.cpp

#include "interpreter.h"
#include "context.h"
#include <iostream>
using namespace std;

abstract_expression::abstract_expression()
{
}

abstract_expression::~abstract_expression()
{
}

//-------------------A--------------------
terminal_expression::terminal_expression(const string &statement)
        :_statement(statement)
{
}

terminal_expression::~terminal_expression()
{
}

void terminal_expression::interpreter(const context &c)
{
        cout<<_statement<<" -- TERMINAL_EXPRESSION"<<endl;
}

//--------------------B--------------------
non_terminal_expression::non_terminal_expression(abstract_expression *exp,int times)
        :_expression(exp),_times(times)
{
}

non_terminal_expression::~non_terminal_expression()
{
}

void non_terminal_expression::interpreter(const context &c)
{
        for (int i = 0; i < _times; ++i)
                _expression->interpreter(c);
}

//main.cpp

#include "context.h"
#include "interpreter.h"

int main(int argc,char **argv)
{
        context * p_c = new context();
        abstract_expression *p_te = new terminal_expression("hello");
        abstract_expression *p_no = new non_terminal_expression(p_te,2);

        p_no->interpreter(*p_c);

   

运行结果：

$ ./interpreter.exe
hello -- TERMINAL_EXPRESSION
hello -- TERMINAL_EXPRESSION