首页 > 代码库 > Interpreter - 解释器模式

Interpreter - 解释器模式

2024-07-12 07:10:50   228人阅读

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

类型
行为型模式

案例
像非常熟知的正则表达式就是描述字符串模式的一种标准语言，它为每一个模式都构造了一个特定的算法。


AbstractExpression - 一个抽象的解释操作，这个接口为抽象语法树中所有的节点所共享。
TerminalExpression - 终结符表达式，实现与文法中的终结符相关联的解释操作。
NonterminalExpression - 非终结符表达式，对文法中每一条规则R1R2...Rn都需要一个NonterminalExpressoin。
Context - 上下文，包含解释器之外的一些全局信息。

比如现在有一些表达式：
  1. PRINT MyLanguage: NEXTLINE 
  2. LOOP 2 
  3.     PRINT Hello SPACE
  4.     PRINT world! NEXTLINE 
  5. BREAK 
  6. END
要解释这些语句，我们先用Context把他们分成一个一个的单词，然后通过IteratorExpression遍历这个Context得到每一个字符，然后调用具体的解释器进行解释，比如LoopExpression， CommandExpression，其中IteratorExpression和LoopExpression是非终结符表达式，CommandExpression四终结符表达式：


Context类进行输入字符串的分解，并能获取单一表达式：
  1. class Context {
  2. public:
  3.     Context(const string str)
  4.     {
  5.         m_size = splitStr(str, m_strs);
  6.     }
  7.    
  8.     string current() 
  9.     {
  10.         return m_strs[m_size];
  11.     }
  13.     string next() 
  14.     {
  15.         return m_strs[++m_size];
  16.     }
  17. private:
  18.     vector<string> m_strs;
  19.     int m_size;
  20. }
AbstractExpression定义了一个统一的接口：
  1. class AbstractExpression {
  2. public:
  3.     virtual void interpret(Context* context) = 0;
  4.     virtual void execute() = 0;
  5. }
在IteratorExpression中进行Context中字符串的遍历，并分配合适的解释器：
  1. class IteratorExpression : public AbstractExpression {
  2. public:
  3.     virtual void interpret(Context* context);
  4.     virtual void execute();
  6. private:
  7.     vector<AbstractExpression*> m_exps;
  8. }
  10. void IteratorExpression::interpret(Context* context)
  11. {
  12.     while(context->current() != "END")
  13.     {
  14.        if(context->current() == "LOOP")
  15.        { 
  16.             LoopExpression* loopExp = new LoopExpression(context);
  17.             m_exp.insert(loopExp);
  18.         }
  19.         else
  20.         {
  21.             CommandExpresion* cmdExp = new CommandExpression(context);
  22.             m_exps.insert(cmdExp);
  23.         }
  24.     }
  25. }
  27. void IteratorExpresion::execute()
  28. {
  29.     for(int i = 0; i < m_str.size(); ++i)
  30.         m_exps[i]->execute();
  31. }
在LoopExpression中处理LOOP和BREAK之间的内容，并分配合适的解释器：
  1. class LoopExpression : public AbstractExpresion
  2. {
  3. public:
  4.     virtual void interpret(Context* context);
  5.     virtual void execute();
  6. private:
  7.     vector<AbstractExpression*> m_exps;
  8.     int m_count;
  9. }
  10. 

  11. void LoopExpression::interpret(Context* context)
  12. {
  13.     while(context->current() != "BREAK")
  14.     {
  15.         if(context->current() == "LOOP")
  16.         { 
  17.             m_count = context->next().toInt();
  18.         }
  19.         else 
  20.         {
  21.             CommandExpresion* cmdExp = new CommandExpression(context);
  22.             m_exps.insert(cmdExp); 
  23.         }
  24.     }
  25. }
  26. 

  27. void LoopExpression::execute()
  28. {
  29.     for(int i = 0; i < m_count; ++i)
  30.         for(int j = 0; j < m_exps.size(); ++j)
  31.             m_exps[j]->execute();
  32. }
在CommandExpression中决定具体解释操作：
  1. class CommandExpression : public AbstractExpression
  2. {
  3. public:
  4.     virtual void interpret(Context* context);
  5.     virtual void execute();
  6. private:
  7.     string m_name;
  8.     string m_text;
  9. }
  10. 

  11. void CommandExpression::interpret(Context* context)
  12. {
  13.     m_name = context->current();
  14.     if(context->current() == "PRINT")
  15.     {  
  16.         m_text = context->next();
  17.     }
  18.     context->next();
  19. }
  21. void CommandExpression::execute()
  22. {
  23.     if(m_name == "PRINT")
  24.         cout << m_text;
  25.     else if(m_name == "NEXTLINE")
  26.         cout << endl;
  27.     else if(m_name == "SPACE")
  28.         cout << " ";
  29. }
有了以上对类的定义，就可以输出我们想要的结果了
  1. string str = "PRINT MyLanguage: NEXTLINE LOOP 2 PRINT Hello SPACE PRINT world! NEXTLINE BREAK END";
  2. Context* context = new Context(str);
  3. IteratorExpression* iterExp = new IteratorExpression();
  4. iterExp->interpret(context);
  5. iterExp->execute();
结果：
  1. MyLauguage:
  2. Hello world!
  3. Hello world!


联系
我们