Interpreter模式

Interpreter模式

    给定一个语言，定义它的语法的一种表示(如一些应用提供了内建的脚本或宏来让用户可以定义他们自己能够在系统中进行的操作)，

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

    一个简单常用的例子是搜索匹配一个模式的字符串。与其为每一个模式都构造一个特定的算法，不如使用一种通用的搜索算法来解释执行

一个正则表达式，该正则表达式定义了带匹配的字符串的集合。

    另一个常用的例子是XML格式的数据解析，现在很多开发平台都提供了对XML格式数据的解析，但在移动设备上可能更需要自己去设计，

Interpreter模式提供了一种很好的组织和设计这种解析器的架构。

    Interpreter模式使用类来表示文法规则，因此很容易实现文法的扩展。它也易于实现文法，因为抽象语法树中各个节点的类的实现大体

类似，这些类易与编写。但是，解释器模式为文法中的每条规则至少定义了一个类，因此包含许多规则的文法可能难以管理和维护。

C++代码示例：

//只说明了模式的组织和使用，实际的解释Interpret逻辑没有提供

//context.h

#ifndef CONTEXT_H
#define CONTEXT_H

class Context{

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

#endif // CONTEXT_H

//context.cpp

#include "context.h"

Context::Context(){

}

Context::~Context(){

}
</pre>
//interpret.h
#ifndef INTERPRET_H
#define INTERPRET_H

#include <string>

using namespace std;

class Context;

class AbstractExpression{

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

class TerminalExpression : public AbstractExpression{

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

class NonterminalExpression : public AbstractExpression{

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

#endif // INTERPRET_H

   
   

    
    

   
   
<strong>//interpret.cpp</strong>
#include "interpret.h"
#include "context.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* ex = new TerminalExpression("hello");
    AbstractExpression* nex = new NonterminalExpression(ex,2);
    nex->Interpret(*c);
    return 0;
}
运行结果：