设计模式(c++)笔记之二十三（Interpreter模式）

一、描述：

      概念：给定一个语言，定义它的文法的一种表示，并定义一个解释器，这个解释器使用该表示来解释语言中的句子。

最简单的例子是表达式运算。

      Interpreter 模式典型的结构图为: 

      Interpreter 模式中,提供了 TerminalExpression 和 NonterminalExpression 两种表达式的解释方式,Context 类用于为解释过程提供一些附加的信息(例如全局的信息)。

二、实例

我的工程目录:

注释:

main:客户

AbstractExpression:表达式接口 

TerminalExpression:终结符表达

NonterminalExpression:非终符结表达

Context：用于为解释过程提供一些附加的信息(例如全局的信息)。

代码:

表达式接口 ;AbstractExpression类

AbstractExpression.h

#ifndef __Interpreter__Interpret__
#define __Interpreter__Interpret__

#include <iostream>
#include "Context.h"
#include <string>
using namespace std;

class AbstractExpression
{
public:
    virtual ~AbstractExpression();
    virtual void Interpret(const Context& c);
    
protected:
    AbstractExpression();
};

#endif /* defined(__Interpreter__Interpret__) */

AbstractExpression.cpp

#include "AbstractExpression.h"

AbstractExpression::AbstractExpression()
{
}

AbstractExpression::~AbstractExpression()
{
}

void AbstractExpression::Interpret(const Context& c)
{
}

终结符表达:TerminalExpression

TerminalExpression.h

#ifndef __Interpreter__TerminalExpression__
#define __Interpreter__TerminalExpression__

#include <iostream>
#include "AbstractExpression.h"

class TerminalExpression:public AbstractExpression
{
public:
    TerminalExpression(const string& statement);
    ~TerminalExpression();
    void Interpret(const Context& c);
private:
    string _statement;
};

#endif /* defined(__Interpreter__TerminalExpression__) */

TerminalExpression.cpp

#include "TerminalExpression.h"

TerminalExpression::TerminalExpression(const string& statement)
{
    this->_statement = statement;
}

TerminalExpression::~TerminalExpression()
{
}

void TerminalExpression::Interpret(const Context& c)
{
    cout<<this->_statement<<"TerminalExpression"<<endl;
}

非终符结表达：NonterminalExpression

NonterminalExpression.h

#ifndef __Interpreter__NonterminalExpression__
#define __Interpreter__NonterminalExpression__

#include <iostream>
#include "AbstractExpression.h"

class NonterminalExpression:public AbstractExpression
{
public:
    NonterminalExpression(AbstractExpression* expression,int times);
    ~ NonterminalExpression();
    void Interpret(const Context& c);
private:
    AbstractExpression* _expression;
    int _times;
};

#endif /* defined(__Interpreter__NonterminalExpression__) */

NonterminalExpression.cpp

#include "NonterminalExpression.h"

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);
    }
}

用于为解释过程提供一些附加的信息(例如全局的信息)：Context

Context.h

#ifndef __Interpreter__Context__
#define __Interpreter__Context__

#include <iostream>

class Context
{
public:
    Context(){};
    ~Context(){};
};

#endif /* defined(__Interpreter__Context__) */

客户:main

main.cpp

#include <iostream>
#include "Context.h"
#include "AbstractExpression.h"
#include "TerminalExpression.h"
#include "NonterminalExpression.h"

void DoIt()
{
    Context* myContext = new Context();
    AbstractExpression* myTerminalExpression = new TerminalExpression("HelloWorld......");
    
    AbstractExpression * myNonterminalExpression = new NonterminalExpression(myTerminalExpression,3);
    
    myNonterminalExpression->Interpret(*myContext);
}

int main(int argc, const char * argv[])
{
    DoIt();
    // insert code here...
    std::cout << "Hello, World!\n";
    return 0;
}

结果如下:

参考文献：《GoF_23种设计模式解析》