23种设计模式(23)--Interpreter模式

平心而论，之前的22个设计模式大多都是比较常见的，几乎做任何项目都有使用的价值。然而这个Interpreter模式则不然，其适用范围较小。正如其名，此模式大多用来解释一些(自定义的)独特语法，例如某些游戏开发引擎中读取XML文件，或是WindowsPhone开发中的XAML文件，都是使用此模式来进行的。与其说是一种模式，不如说是一种具有通用规范的行为更为准确。

一个简单的例子：一份密码电报，需要通过特定的解读顺序以及某些关键字来解读，才可以获取其内容，而此模式即是大抵如此。

【核心】通过解释器来解释某种特定语法。

UML图：



这里有必要解释一下UML图：

Interpret方法即是解释器本身的行为。

TerminalExpression是终止符表达式，例如A◎B这个表达式中的A,B即是终止符。

NonterminalExpression是非终止符表达式，上式中的◎符号即为非终止符。

Context就是上下文啦，也就是需要被解释的东西。

【大致思路】

string类型的加密电报作为Context传入NonterminalExpression中，

其被后者通过Interpreter方法进行解释，

并输出密码。

Interpreter.h

[cpp] view
plain copy

#ifndef _INTERPRETER_H_  

#define _INTERPRETER_H_  

#include<string>  

  

typedef std::string Context ;  

  

class AbstractExpression  

{  

public:  

    AbstractExpression(){}  

    ~AbstractExpression(){}  

  

    virtual void Interpreter(const Context& context)=0;  

};  

  

class TerminalExpression : public AbstractExpression  

{  

public:  

    TerminalExpression(char kc);  

    ~TerminalExpression(){}  

  

    virtual void Interpreter(const Context& context);  

  

private:  

    char keyChar;  

};  

  

class NonterminalExpression : public AbstractExpression  

{  

public:  

    NonterminalExpression(AbstractExpression* ae);  

    ~NonterminalExpression(){}  

  

    virtual void Interpreter(const Context& context);  

  

private:  

    AbstractExpression* terminalExpression;  

};  

  

#endif  

Interpreter.cpp

[cpp] view
plain copy

#include "Interpreter.h"  

#include<iostream>  

  

TerminalExpression::TerminalExpression(char kc)  

{  

    keyChar = kc;  

}  

  

void TerminalExpression::Interpreter(const Context& context)  

{  

    int length = 0;  

    while (context[length] != '\0')  

    {  

        length++;  

    }  

  

    int numberArray[100];  

    int index = 0;  

  

    for(int i = 0;i < length;i++)  

    {  

        if(keyChar  == context[i])  

            numberArray[index++] = i;  

    }  

  

    for(int i = 0;i < index;i++)  

    {  

        std::cout<<numberArray[i];  

    }  

  

    std::cout<<std::endl;  

}  

  

NonterminalExpression::NonterminalExpression(AbstractExpression* ae)  

{  

    terminalExpression = ae;  

}  

  

void NonterminalExpression::Interpreter(const Context& context)  

{  

    std::cout<<"The password is: ";  

    terminalExpression->Interpreter(context);  

}  

main.cpp

[cpp] view
plain copy

#include "Interpreter.h"  

#include<iostream>  

  

using namespace std;  

  

int main()  

{  

    AbstractExpression* terminal = new TerminalExpression('c');  

    AbstractExpression* nonTerminal = new NonterminalExpression(terminal);  

  

    //First test.  

    string contextFirst = "character of the cars in this chart.";  

    cout<<"Context: "<<contextFirst<<endl;  

    nonTerminal->Interpreter(contextFirst);  

  

    cout<<endl;  

  

    //Second test.  

    terminal = new TerminalExpression('o');  

    nonTerminal = new NonterminalExpression(terminal);  

  

    string contextSecond = "Thanks everyone for your long time supporting.";  

    cout<<"Context: "<<contextSecond<<endl;  

    nonTerminal->Interpreter(contextSecond);  

  

    return 0;  

}  

输出结果：



【注意事项】

嘿嘿，笔者稍微有点偷懒了。使用typedef将string包装为Context。其实真正的Context应该是一个独立类的哦。

在TerminalExpression的构造器中传入的字符就是解码的关键啦。其实正如前文所说，这个设计模式更加注重内部的行为，因此这段代码最重要的应当是TerminalExpression的Interpreter部分。不过也许会有读者问，为何NonterminalExpression的Interpreter部分非常简单，这是因为，非终止符只是作为一种行为的解释，真正的逻辑应当由终止符自己进行的。当然，由于解释器没有统一的形式与逻辑，因此具体的做法还是因程序而异啦。

转自：http://blog.csdn.net/elezeor/article/details/8643758