定义

给定一个语言, 定于它的文法,并定义一个解释器,这个解释器使用改表示来解释语言中的句子。
类型
行为型模式
案例
像很熟知的正則表達式就是描写叙述字符串模式的一种标准语言,它为每个模式都构造了一个特定的算法。
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. string current()
  8. {
  9. return m_strs[m_size];
  10. }
  11. string next()
  12. {
  13. return m_strs[++m_size];
  14. }
  15. private:
  16. vector<string> m_strs;
  17. int m_size;
  18. }
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();
  5. private:
  6. vector<AbstractExpression*> m_exps;
  7. }
  8. void IteratorExpression::interpret(Context* context)
  9. {
  10. while(context->current() != "END")
  11. {
  12. if(context->current() == "LOOP")
  13. {
  14. LoopExpression* loopExp = new LoopExpression(context);
  15. m_exp.insert(loopExp);
  16. }
  17. else
  18. {
  19. CommandExpresion* cmdExp = new CommandExpression(context);
  20. m_exps.insert(cmdExp);
  21. }
  22. }
  23. }
  24. void IteratorExpresion::execute()
  25. {
  26. for(int i = 0; i < m_str.size(); ++i)
  27. m_exps[i]->execute();
  28. }
在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. void LoopExpression::interpret(Context* context)
  11. {
  12. while(context->current() != "BREAK")
  13. {
  14. if(context->current() == "LOOP")
  15. {
  16. m_count = context->next().toInt();
  17. }
  18. else
  19. {
  20. CommandExpresion* cmdExp = new CommandExpression(context);
  21. m_exps.insert(cmdExp);
  22. }
  23. }
  24. }
  25. void LoopExpression::execute()
  26. {
  27. for(int i = 0; i < m_count; ++i)
  28. for(int j = 0; j < m_exps.size(); ++j)
  29. m_exps[j]->execute();
  30. }
在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. void CommandExpression::interpret(Context* context)
  11. {
  12. m_name = context->current();
  13. if(context->current() == "PRINT")
  14. {
  15. m_text = context->next();
  16. }
  17. context->next();
  18. }
  19. void CommandExpression::execute()
  20. {
  21. if(m_name == "PRINT")
  22. cout << m_text;
  23. else if(m_name == "NEXTLINE")
  24. cout << endl;
  25. else if(m_name == "SPACE")
  26. cout << " ";
  27. }
有了以上对类的定义,就能够输出我们想要的结果了

  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!

Interpreter - 解释器模式相关推荐

  1. Interpreter解释器模式

    前言: 关于23种设计模式的所有示例代码请参考:https://github.com/Wuchenwcf/MyCode/tree/master/DP 本文所述代码请参考:https://github. ...

  2. 浅谈Interpreter解释器模式

    一.前言 这是我们23个设计模式中最后一个设计模式了,大家或许也没想到吧,竟然是编译原理上的编译器,这样说可能不对,因为编译器分为几个部分组成呢,比如词法分析器.语法分析器.语义分析器.中间代码优化器 ...

  3. Interpreter(解释器模式)行为型

    解释器模式 一.概述 二.结构 三.实例 四.适用场景 五.优缺点 一.概述 描述:当不懂英文的中国人和不懂中文的外国人交流时会存在沟通障碍.这时有种翻译器能将两种语言进行转换各个对方国家语言,然后进 ...

  4. [转载] C#面向对象设计模式纵横谈——16 Interpreter解释器模式

    主讲:李建忠 来源:http://www.microsoft.com/china/msdn/events/webcasts/shared/webcast/consyscourse/CsharpOOD. ...

  5. 设计模式之解释器模式(Interpreter)摘录

    23种GOF设计模式一般分为三大类:创建型模式.结构型模式.行为模式. 创建型模式抽象了实例化过程,它们帮助一个系统独立于如何创建.组合和表示它的那些对象.一个类创建型模式使用继承改变被实例化的类,而 ...

  6. java interpreter_解释器模式(Interpreter)Java

    定义: 解释器模式(interpreter):给定一个语言,定义它的文法的一种表示,并定义一个解释器,这个解释器使用该表示来解释语言中的句子. 结构图: AbstractExpression解释器模式 ...

  7. 设计模式循序渐进(9)解释器模式 Interpreter

    通过解释器模式实现阿拉伯数字与罗马数字的相互转换. 具体的模式分析解说日后补发. Delphi代码: unit uInt2RomeInterpreter; { 单元说明:将整数转换为罗马数字      ...

  8. 解释器模式(行为模式)

    设计模式之Interpreter - 解释器模式             2008-06-24 10:41:46 分类: 项目管理 源地址:http://blog.chinaunix.net/uid- ...

  9. 解释器模式(interpreter)解析例子

    摘要:本文深入浅出的讲述了设计模式中的解释器模式,并给出了简单的示例,例子浅显易懂,并附带源代码. 解释器模式属于行为型模式,其意图是给定一个语言,定义它的文法表示,并定义一个解释器,这个解释器使用该 ...

最新文章

  1. Kubernetes学习笔记二:Namespace,Cgroups 的隔离与应用
  2. 脑机交互研究及标准化实践
  3. futuretask java 并发请求_图文并茂理解 Java 多线程
  4. ClassLoader工作机制
  5. Raid技术在Linux下的使用
  6. 反射型XSS漏洞详解
  7. lambda表达式_Lambda表达式详解
  8. 数据结构和数据类型之间的关系
  9. Java单例模式的七种写法
  10. Docker精华问答 | Docker vs VM
  11. 项目中有出现过缓存击穿,简单说说怎么回事?
  12. JVM 排查问题实战
  13. 前端 JavaScript 条件语句优化
  14. springmvc线程安全问题
  15. 武大高级软件工程2017评分汇总
  16. html小写数字怎么转换大写,如何将数字123转化成大写的文字 一百二十三 或 一二三?...
  17. 扩展欧几里得算法——Python详解
  18. Python软件编程等级考试四级——20210905
  19. QT visual assist x不能稳定工作
  20. 解决多个数独重叠联系

热门文章

  1. python默认数据类型转换_Python 数据类型转换
  2. java 获取第一帧_java获取视频的第一帧
  3. paddle中的自动求解梯度 : autograd.backward
  4. 如何自行绕制所需要的2.2uH的电感?
  5. 逐飞mini车样品说明
  6. 电子秤专用模拟/数字(A/D)转换器芯片 HX711
  7. 简单分解帮助看清复杂问题
  8. python语言接口_Python-接口自动化(一)
  9. bs程序在linux下部署,在windows10 Linux (centos7)中安装go golang (够浪) 并测试运行
  10. mysql高级版本的默认密码_MySQL高版本默认密码查找