设计模式 解释器模式

1、interpreter.h

#ifndef INTERPRETER_H
#define INTERPRETER_H

#include <iostream>
#include <string>
#include <list>
using namespace std;

class Context //要解释的文本
{
private:
    string inputString;
    string outputString;
public:
    string getInput();
    void setInput(const string& s);
    string getOutput();
    void setOutput(const string& s);
};

class Expression //解释文本的基类
{
public:
    virtual void Interpret(Context* context) = 0;
};

class AbstractExpression : public Expression //抽象解释文本的具体类，继承于Expression
{
public:
    virtual void Interpret(Context* context);
};

class NormalExpression : public Expression //标准解释文本的具体类，继承于Expression
{
public:
    virtual void Interpret(Context* context);
};
#endif // INTERPRETER_H

2、interpreter.cpp

#include "interpreter.h"

void Context::setInput(const string &s)
{
    inputString = s;
}

string Context::getInput()
{
    return inputString;
}

void Context::setOutput(const string &s)
{
    outputString = s;
}

string Context::getOutput()
{
    return outputString;
}

void AbstractExpression::Interpret(Context *context)
{
    context->setOutput("AbstractExpression:" + context->getInput());
    cout << context->getOutput() << endl;
}

void NormalExpression::Interpret(Context *context)
{
    context->setOutput("NormalExpression:" + context->getInput());
    cout << context->getOutput() << endl;
}

3、main.cpp

/*
作者：jhluroom弹   QQ：454676244  MSN：jhlu0815@hotmail.com
开发IDE：qt creater
开发环境：QT C++
参考网站：神秘果：http://www.shenmiguo.com/

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

理解：
1.定义了一个类体系，用于实现一个小型语言的解释器。它与组合模式很相似，而且常常利用组合模式来实现语法树的构建。
2.是一种特殊的设计模式，它建立一个解释器，对于特定的计算机程序设计语言，用来解释预先定义的文法。
  简单地说，Interpreter模式是一种简单的语法解释器构架。

要点：
1.当有一个语言需要解释执行, 并且你可将该语言中的句子表示为一个抽象语法树时，可使用解释器模式。
2.如下情况效果更好：该文法简单对于复杂的文法, 文法的类层次变得庞大而无法管理。此时语法分析程序生成器这样的工具是更好的选择。
  它们无需构建抽象语法树即可解释表达式, 这样可以节省空间而且还可能节省时间。
3.效率不是一个关键问题，最高效的解释器通常不是通过直接解释语法分析树实现的, 而是首先将它们转换成另一种形式。
  例如，正则表达式通常被转换成状态机。但即使在这种情况下, 转换器仍可用解释器模式实现, 该模式仍是有用的。

应用：
我们需要在Client中解释某语法，Client调用Context来存储语法规则，并调用解释器Expression类树来对该文法加以解释。

以上文字说明，从网上整理而来，有可能部分与其他同仁相同，请谅解，希望我们能够共同交流，谢谢！
*/

#include <QtCore/QCoreApplication>

#include "interpreter.h"

int main(int argc, char *argv[])
{
    cout << "=== jhluroom start ========" << endl;

    //Client
    Context* context = new Context;
    context->setInput("jhluroom");
    list<Expression*> listExpression;

    listExpression.push_back(new AbstractExpression);
    listExpression.push_back(new NormalExpression);
    listExpression.push_back(new AbstractExpression);
    listExpression.push_back(new AbstractExpression);
    listExpression.push_back(new NormalExpression);

    for (list<Expression*>::iterator iter = listExpression.begin(); iter != listExpression.end(); ++iter)
    {
        (*iter)->Interpret(context);
    }

    for (list<Expression*>::iterator iter = listExpression.begin(); iter != listExpression.end(); ++iter)
    {
        delete (*iter);
    }
    delete context;

    cout << "=== jhluroom finish _^_ ===" << endl;
    return 0;
}

运行结果：

=== jhluroom start ========

AbstractExpression:jhluroom
NormalExpression:jhluroom
AbstractExpression:jhluroom
AbstractExpression:jhluroom
NormalExpression:jhluroom

=== jhluroom finish _^_ ===