正文已添加至索引,此时能够设想将那一个题材的实例表述为多个言语中的句子

情势动机
图片 1

情势动机
图片 2

为便宜读者,本文已添加至索引:

即便在系统中某一一定项指标标题时有发生的频率很高,此时能够设想将那么些题材的实例表述为1个言语中的句子,由此能够创设五个解释器,该解释器通过解释这几个句子来缓解这几个难题。
解释器格局描述了如何构成2个粗略的言语解释器,重要接纳在动用面向对象语言开发的编写翻译器中。

倘若在系统中某一一定类型的题材发生的效用很高,此时得以考虑将那么些难点的实例表述为贰个语言中的句子,由此得以营造一个解释器,该解释器通过解释那个句子来消除那几个难题。
解释器情势描述了怎么构成二个简短的言语解释器,首要选取在选择面向对象语言开发的编写翻译器中。

设计格局

### 学习笔记索引

情势定义
解释器方式(Interpreter Pattern)
:定义语言的文法,并且成立二个解释器来解释该语言中的句子,那里的“语言”意思是行使规定格式和语法的代码,它是一体系行为型格局。
Interpreter Pattern: Given a language, define a representation for its
grammar along with an interpreter that uses the representation to
interpret sentences in the language.
Frequency of use: low
UML图
图片 3

形式定义
解释器形式(Interpreter Pattern)
:定义语言的文法,并且创设贰个解释器来表达该语言中的句子,那里的“语言”意思是应用规定格式和语法的代码,它是一类别行为型方式。
Interpreter Pattern: Given a language, define a representation for its
grammar along with an interpreter that uses the representation to
interpret sentences in the language.
Frequency of use: low
UML图
图片 4

写在前边

“笔者刚写了个小程序,要求您来涉足下。”小编把MM叫到本人的处理器旁,“来把下边那条命令打进去,那是个练习打(Pian)符(ni)号(de)的小程序,看看您能还是无法一切打正确”。

[*_]_7@1_9@1/(_5@0_3@0)*2/((_4@0)_2$1)_$2^/$1+(_7@0)*2/_$1_6$3/$3_2$3/_3$3_3@0/_5$3

MM诧异地看望自身,然后可怜巴巴地坐到屏幕前,对着键盘三个字一个字地敲。她打字超慢的,各个符号都是用多少人口打进去的。她打着打着,说想哭了。笔者赶忙告诉她,加油,全打正确了有惊喜。

到头来,她敲下了回车键。映入眼帘的是:

图片 5图片 6

       _         _
     *   *     *   *     
    *      * *      *    
    *       *       *    
     *             *     
       *         *       
          *   *          
            *            

See Result

她突然就欢天喜地起来,问小编这些是怎么回事。笔者报告她,“那注脚你刚才的命令输对了,电脑依据指令画出了它~。要不再接再砺,试试下边这些更有挑衅性的?”

[#*]_@1*5/_(_2@1*2)/$0_9@1*6_(_@1*4)*2_3@1*5/$0_6$0_2$0*2+(_$0)*3/$0_5$0_3$0*3_3@1*8/(_2@0*2)_4@0+$3_3$3*2+(_@0*2)_2$3/$4_4@0_$3_2$3_4@0*3_3$3_2$3/@0*7_5@0*5_4$3_7@0*6

……

是否读者你也想精通那么些会是怎么结果了啊?这本来跟我们前些天的核心,解释器情势有关啦!会在演示一节开展。

其实,大家日常触及到的解释器情势相关的莫过于例子并不太多,最普遍的其实正则表明式了。它经过鲜明一多重的文法规则,并给予了连带的解说操作,从而成为处理字符串的通用强大的工具。首先大家询问下解释器形式的连锁技能中央,然后在示范部分,大家将解释上文中所出现的莫名的姿态。

格局组织
解释器形式涵盖如下剧中人物:
AbstractExpression: 抽象表明式
TerminalExpression: 终结符表明式
NonterminalExpression: 非终结符表明式
Context: 环境类
Client: 客户类

情势组织
解释器方式涵盖如下剧中人物:
AbstractExpression: 抽象表明式
TerminalExpression: 终结符表明式
NonterminalExpression: 非终结符表达式
Context: 环境类
Client: 客户类

要领梳理

指标分类

  • 类行为型形式

范围准则

  • 类(该形式处理类和子类之间的关系,那些关乎通过持续建立,是静态的,在编写翻译时刻便显著下来了)

重大功效

  • 给定1个语言,定义它的文法的一种象征,并定义贰个解释器,那个解释器使用该表示来解释语言中的句子。

适用意况

  • 当有贰个言语需求解释施行,
    并且我们可将该语言中的句子表示为三个空洞语法树时,可应用解释器方式。当存在以下情状时,效果最好:

    • 该文法简单。对于复杂的文法, 文法的类层次变得巨大而望洋兴叹管理
    • 频率不是二个关键难点。最火速的解释器平时不是因此从来表达语法分析树完成。

到场部分

  • AbstractExpression(抽象表明式):声美赞臣个抽象的诠释操作,那一个接口为架空语法树中兼有的节点所共享
  • TerminalExpression(终结符表达式):完结与文法中的终结符相关联的解释操作,一个句子中的每一个终结符要求该类的1个实例
  • NonterminalExpression(非终结符表明式):为文法中的非终结符完结解释操作。解释时,一般要递归调用它所保证的AbstractExpression类型对象的表达操作
  • Context(上下文):包括解释器之外的片段大局消息
  • Client(用户):创设(或被给定)
    表示该文法定义的语言中四个一定的语句的架空语法树。该抽象语法树由TerminalExpression和NonterminalExpression的实例装配而成。

合作进度

  • Client创设三个句子,它是TerminalExpression和NonterminalExpression的实例的3个华而不实语法树,然后开始化上下文,并调用解释操作。
  • 每一非终结符表明式节点定义相应子表明式的分解操作。
  • 每一节点的解释操成效上下文来储存和访问解释器的场馆。

UML图

图片 7

方式分析
解释器情势描述了怎么着为简便的语言定义一个文法,怎么着在该语言中象征2个句子,以及如何分解这一个句子。
文法规则实例:
expression ::= value | symbol
symbol ::= expression ‘+’ expression | expression ‘-‘ expression
value ::= an integer //三个整数值
在文法规则定义中得以运用部分符号来表示不一样的意思,如应用“|”表示或,使用“{”和“}”表示结合,使用“*”表示出现0次或频仍等,在那之中使用作用最高的标记是代表或涉及的“|”

情势分析
解释器方式描述了何等为简易的言语定义3个文法,怎样在该语言中意味一个句子,以及怎么样解释这么些句子。
文法规则实例:
expression ::= value | symbol
symbol ::= expression ‘+’ expression | expression ‘-‘ expression
value ::= an integer //1个整数值
在文法规则定义中得以选择一些标志来表示分化的意义,如使用“|”表示或,使用“{”和“}”表示结合,使用“*”表示出现0次或频仍等,个中使用频率最高的符号是象征或提到的“|”

示范分析 – 字符画解释器

为了让MM不明觉厉,作者想开了通过简单的解释器来贯彻,从字符串到三个字符画的变换进度。小编觉得使用stringstream流能够便宜地营造一个字符画,由此,大家首先确定我们达成这么些形式的上下文(Context)正是stringstream对象。然后大家定义一些有血有肉的字符操作表达式。它们是足以画出字符画的局地基本操作:

TerminalExpression:

  • Constant:常量表明式。它也是得了符表明式。它的诠释操作就是将1个定点的string插入到Context流中。

NonterminalExpression:

  • RepeatExpression:重复表达式。它是非终结符表明式。它的解释操作正是使3个Expression重复N次。
  • AddExpression:加法表明式。非终结符表明式。它的表明操作是使四个Expression拼接在一道。
  • ReverseExpression:反转表达式。非终结符表达式。它的解说操作是使多少个Expression逆序。

能够见见那多少个表明式是可以整合泛泛语法树的。让我们看看代码:

图片 8图片 9

 1 #ifndef EXPRESSION_H_INCLUDED
 2 #define EXPRESSION_H_INCLUDED
 3 
 4 #include <string>
 5 #include <sstream>
 6 
 7 using namespace std;
 8 
 9 // ... Abstract Class ...
10 class Expression {
11 public:
12     Expression() {}
13     virtual ~Expression() {}
14 
15     virtual void eval(stringstream&) = 0;
16 };
17 
18 // ... RepeatExpression Class ...
19 class RepeatExpression : public Expression {
20 public:
21     RepeatExpression(Expression*, int);
22 
23     void eval(stringstream&);
24 private:
25     Expression* _oper;
26     int         _mNum;
27 };
28 
29 // ... AddExpression Class ...
30 class AddExpression : public Expression {
31 public:
32     AddExpression(Expression*, Expression*);
33 
34     void eval(stringstream&);
35 private:
36     Expression* _oper1;
37     Expression* _oper2;
38 };
39 
40 // ... ReverseExpression Class ...
41 class ReverseExpression : public Expression {
42 public:
43     ReverseExpression(Expression*);
44 
45     void eval(stringstream&);
46 private:
47     Expression* _oper;
48 };
49 
50 // ... Constant Class ...
51 class Constant : public Expression {
52 public:
53     Constant(const char*);
54     Constant(const char*, int);
55 
56     void eval(stringstream&);
57 private:
58     string _mStr;
59 };
60 
61 #endif // EXPRESSION_H_INCLUDED

expression.h

图片 10图片 11

 1 #include "expression.h"
 2 #include <algorithm>
 3 using namespace std;
 4 
 5 // ... RepeatExpression  BEGIN ...
 6 RepeatExpression::RepeatExpression(Expression* oper, int m) {
 7     _oper = oper;
 8     _mNum = m;
 9 }
10 
11 void RepeatExpression::eval(stringstream& ss) {
12     stringstream t_str;
13     _oper->eval(t_str);
14     for (int i = 0; i < _mNum; i++) {
15         ss << t_str.str();
16     }
17 }
18 // ... RepeatExpression  END ...
19 
20 // ... AddExpression BEGIN ...
21 AddExpression::AddExpression(Expression* oper1, Expression* oper2) {
22     _oper1 = oper1;
23     _oper2 = oper2;
24 }
25 
26 void AddExpression::eval(stringstream& ss) {
27     stringstream t_str;
28     _oper1->eval(t_str);
29     _oper2->eval(t_str);
30     ss << t_str.str();
31 }
32 // ... AddExpression END ...
33 
34 // ... ReverseExpression BEGIN ...
35 ReverseExpression::ReverseExpression(Expression* o) {
36     _oper = o;
37 }
38 
39 void ReverseExpression::eval(stringstream& ss) {
40     stringstream t_str;
41     _oper->eval(t_str);
42     string str = t_str.str();
43     reverse(str.begin(), str.end());
44     ss << str;
45 }
46 // ... ReverseExpression END ...
47 
48 // ... Constant BEGIN ...
49 Constant::Constant(const char* str) {
50     _mStr = string(str);
51 }
52 
53 Constant::Constant(const char* str, int len) {
54     _mStr = string(str, len);
55 }
56 
57 void Constant::eval(stringstream& ss) {
58     ss << _mStr;
59 }
60 // ... Constant END ...

expression.cpp

到了此处,大家假诺想生成二个字符画: “o>_<o“,能够如此做:

1 stringstream ss;
2 
3 Expression* e1 = new RepeatExpression(new Constant("~"), 2);
4 Expression* e2 = new AddExpression(e1, new Constant("o>"));
5 Expression* e3 = new AddExpression(e2, new Constant("_"));
6 Expression* result = new AddExpression(e3, new ReverseExpression(e2));
7 
8 result->eval(ss);
9 cout << ss.str() << endl;

实则解释器形式部分的编制程序已经停止了。但肯定那一个并不曾达到规定的标准前言中翻译那串莫名字符串的目标。为此,大家还需在此基础上,定义一些语法,写叁个语法分析器来将那串字符塑造成抽象语法树。那里,笔者就偷懒了,写了个万分简单,没有怎么优化的语法分析器:

// 定义的一些符号含义:
//      []  ----  字符集
//      ()  ----  分组
//      @N  ----  取字符集中第N个字符(N从0开始)
//      *N  ----  *前面的表达式重复N次
//      $N  ----  取第N个分组(N从0开始,分组由括号顺序确定,嵌套的括号以从里到外的规则递增)
//      +   ----  加号两边的表达式拼接
//      ^   ----  ^前面的表达式逆序
//      _N  ----  拼接N个空格
//      /   ----  拼接一个换行符

切实代码如下:

图片 12图片 13

 1 #ifndef TRANSLATOR_H_INCLUDED
 2 #define TRANSLATOR_H_INCLUDED
 3 
 4 #include <string>
 5 #include <vector>
 6 using namespace std;
 7 
 8 class Expression;
 9 
10 class Translator {
11 public:
12     Translator();
13     ~Translator();
14     Expression* translate(string& str);
15 
16 private:
17     Expression* translateExp(string& str);
18     char*   _mCharSet;
19     vector<Expression*> _mExpGroup;
20 };
21 
22 #endif // TRANSLATOR_H_INCLUDED

Translator.h

图片 14图片 15

  1 #include "Translator.h"
  2 #include "expression.h"
  3 #include <cstring>
  4 #include <cstdlib>
  5 using namespace std;
  6 
  7 Translator::Translator() {
  8     _mCharSet = 0;
  9 }
 10 
 11 Translator::~Translator() {
 12     if (_mCharSet) delete[] _mCharSet;
 13 }
 14 
 15 Expression* Translator::translate(string& str) {
 16     Expression* result = 0;
 17     for(unsigned int i = 0; i < str.size(); i++ ) {
 18         if (str.at(i) == '[') {
 19             int sEnd = str.find_last_of("]");
 20             int sLen = sEnd - i - 1;
 21             if (_mCharSet) delete[] _mCharSet;
 22             _mCharSet = new char[sLen];
 23             strcpy(_mCharSet, str.substr(i+1, sLen).data());
 24             i = sEnd;
 25         } else if (str.at(i) == '@') {
 26             int sChar = atoi(str.substr(i + 1, 1).c_str());
 27             Expression* tmp = new Constant(&_mCharSet[sChar], 1);
 28             result = tmp;
 29             i = i + 1;
 30         } else if (str.at(i) == '(') {
 31             int pos = i + 1;
 32             int left = 0;
 33             for (;pos < str.size(); pos++) {
 34                 if (str.at(pos) == ')') {
 35                     if (left == 0)
 36                         break;
 37                     else
 38                         left--;
 39                 }
 40                 if (str.at(pos) == '(')
 41                     left++;
 42             }
 43             string t_str = str.substr(i + 1, pos - i - 1);
 44             Expression* tmp = translate(t_str);
 45             _mExpGroup.push_back(tmp);
 46             result = tmp;
 47             i = pos;
 48         } else if (str.at(i) == '+') {
 49             string t_str = str.substr(i + 1);
 50             result = new AddExpression(result, translate(t_str));
 51             break;
 52         } else if (str.at(i) == '*') {
 53             int pos = i+1;
 54             for (;pos < str.size();pos++) {
 55                 if (str.at(pos) > '9' || str.at(pos) < '0') break;
 56             }
 57             pos--;
 58             int sRep = atoi(str.substr(i + 1, pos - i).c_str());
 59             Expression* tmp = new RepeatExpression(result, sRep);
 60             result = tmp;
 61             i = pos;
 62         } else if (str.at(i) == '^') {
 63             Expression* tmp = new ReverseExpression(result);
 64             result = tmp;
 65         } else if (str.at(i) == '$') {
 66             int pos = i+1;
 67             for (;pos < str.size();pos++) {
 68                 if (str.at(pos) > '9' || str.at(pos) < '0') break;
 69             }
 70             pos--;
 71             int nGroup = atoi(str.substr(i + 1, pos - i).c_str());
 72             if (nGroup >= _mExpGroup.size()) return 0;
 73             result = _mExpGroup[nGroup];
 74             i = pos;
 75         } else if (str.at(i) == '/') {
 76             string t_str = str.substr(i + 1);
 77             Expression* tmp = new Constant("\n");
 78             if (!result) {
 79                 result = new AddExpression(tmp, translate(t_str));
 80             }
 81             else {
 82                 result = new AddExpression(new AddExpression(result, tmp), translate(t_str));
 83             }
 84             break;
 85         } else if (str.at(i) == '_') {
 86             int pos = i+1;
 87             for (;pos < str.size();pos++) {
 88                 if (str.at(pos) > '9' || str.at(pos) < '0') break;
 89             }
 90             pos--;
 91             int sRep = (pos == i) ? 1 : atoi(str.substr(i + 1, pos - i).c_str());
 92             string t_str = str.substr(pos + 1);
 93             Expression* tmp = new RepeatExpression(new Constant(" "), sRep);
 94             if (!result) {
 95                 result = new AddExpression(tmp, translate(t_str));
 96             }
 97             else {
 98                 result = new AddExpression(new AddExpression(result, tmp), translate(t_str));
 99             }
100             break;
101         }
102     }
103     return result;
104 }

Translator.cpp

再度强调,那几个语法分析器,并不是解释器情势所讲的剧情。好了,写个简易的main函数就足以运作了:

 1 #include <iostream>
 2 #include "expression.h"
 3 #include "Translator.h"
 4 
 5 using namespace std;
 6 
 7 int main()
 8 {
 9     cout << "Input your command below: " << endl;
10     string str;
11     getline(cin, str);
12     Translator translator;
13     
14     // ... Generate the Abstract Grammar Tree by Translator
15     Expression* myExp = translator.translate(str);
16     if (!myExp) return 1;
17    
18     // ... Call Its Interpret Operation
19     stringstream ss;
20     myExp->eval(ss);
21 
22     cout << ss.str() << endl;
23     return 0;
24 }

那么大家输入以前第1串字符试试:

 *****
   **
  **         ******  **** ****   *****
  **        **    **  **   **   **   **
  **       **     **  **  **   ******** 
  ##    #  ##     ##  ## ##    ##
 ##    #   ##    ##    ###     ##    ##
#######     #####      ##       ######

MM表示很神采飞扬。对于那些示例的UML图:

图片 16

虚幻语法树:
除外运用文法规则来定义贰个语言,在解释器形式中还足以经过一种叫做抽象语法树(Abstract
Syntax Tree,
AST)的图纸格局来直观地代表语言的三结合,每一棵抽象语法树对应1个言语实例。
图片 17

空洞语法树:
除外行使文法规则来定义三个言语,在解释器形式中还足以经过一种叫做抽象语法树(Abstract
Syntax Tree,
AST)的图纸方式来直观地代表语言的构成,每一棵抽象语法树对应3个言语实例。
图片 18

特征总结

小编们能够见见,Interpreter解释器形式有以下优点和瑕疵:

  1. 简单变动和扩展文法。因为该形式采纳类来代表文法规则,大家能够利用持续来改变或扩充该文法。多加一种文法就剧增2个类。
  2. 也不难落实文法。定义抽象语法树中相继节点的类的达成大体类似。平常它们也可用四个编写翻译器或语法分析程序生成器自动生成。
  3. 复杂的文法难以保险。解释器形式为文法中的每一条规则至少定义了叁个类,由此包蕴众多平整的文法只怕麻烦管理和维护。

再者我们得以见到,它和别的设计形式:Composite(组合)模式有着广大相通的地方。具体能够参见此前的笔记。

架空语法树描述了哪些整合1个复杂的语句,通过对抽象语法树的分析,可以辨别出语言中的终结符和非终结符类。
在解释器形式中,各样终结符和非终结符都有贰个具体类与之对应,正因为运用类来表示每2个语法规则,使得系统全体较好的扩充性和灵活性。

架空语法树描述了怎么整合三个复杂的语句,通过对抽象语法树的分析,能够分辨出语言中的终结符和非终结符类。
在解释器方式中,每种终结符和非终结符都有三个具体类与之相应,正因为运用类来代表每八个语法规则,使得系统具备较好的扩张性和灵活性。

写在最终

明天的笔记就到那边了,欢迎大家批评指正!就算以为能够的话,好文推荐时而,小编会相当多谢的!

格局实例与分析
以中国和英国文翻译系统为例来介绍解释器格局
系统布局
图片 19

情势实例与分析
以中英文翻译系统为例来介绍解释器情势
系统布局
图片 20

AbstractExpression接口 IExpression.cs

AbstractExpression接口 IExpression.cs

using System.Text;

namespace InterpreterPattern
{
    //定义AbstractExpression接口
    interface IExpression
    {
        void Interpret(StringBuilder sb);
    }
}
using System.Text;

namespace InterpreterPattern
{
    //定义AbstractExpression接口
    interface IExpression
    {
        void Interpret(StringBuilder sb);
    }
}

具体的Expression WordExpression.cs

具体的Expression WordExpression.cs

using System.Text;

namespace InterpreterPattern
{
    //定义具体的Expression,这里包括对英文单词的翻译和对英文句号的翻译。
    public class WordExpression : IExpression
    {
        private string _value;
        public WordExpression(string value)
        {
            _value = value;
        }
        public void Interpret(StringBuilder sb)
        {
            sb.Append(ChineseEnglishDict.GetEnglish(_value.ToLower()));
        }
    }
}
using System.Text;

namespace InterpreterPattern
{
    //定义具体的Expression,这里包括对英文单词的翻译和对英文句号的翻译。
    public class WordExpression : IExpression
    {
        private string _value;
        public WordExpression(string value)
        {
            _value = value;
        }
        public void Interpret(StringBuilder sb)
        {
            sb.Append(ChineseEnglishDict.GetEnglish(_value.ToLower()));
        }
    }
}

SymbolExpression.cs

SymbolExpression.cs

using System.Text;

namespace InterpreterPattern
{
    //对英文句号的翻译
    public class SymbolExpression : IExpression
    {
        private string _value;
        public SymbolExpression(string value)
        {
            this._value = value;
        }

        public void Interpret(StringBuilder sb)
        {
            switch (_value)
            {
                case ".":
                    sb.Append("。");
                    break;
            }
        }
    }
}
using System.Text;

namespace InterpreterPattern
{
    //对英文句号的翻译
    public class SymbolExpression : IExpression
    {
        private string _value;
        public SymbolExpression(string value)
        {
            this._value = value;
        }

        public void Interpret(StringBuilder sb)
        {
            switch (_value)
            {
                case ".":
                    sb.Append("。");
                    break;
            }
        }
    }
}

Context: 环境类 ChineseEnglishDict.cs

Context: 环境类 ChineseEnglishDict.cs

using System.Collections.Generic;

namespace InterpreterPattern
{
    public static class ChineseEnglishDict
    {
        private static Dictionary<string, string> _dictory = new Dictionary<string, string>();

        static ChineseEnglishDict()
        {
            _dictory.Add("this", "这");
            _dictory.Add("is", "是");
            _dictory.Add("an", "一个");
            _dictory.Add("apple", "苹果");
        }
        public static string GetEnglish(string value)
        {
            return _dictory[value];
        }
    }
}
using System.Collections.Generic;

namespace InterpreterPattern
{
    public static class ChineseEnglishDict
    {
        private static Dictionary<string, string> _dictory = new Dictionary<string, string>();

        static ChineseEnglishDict()
        {
            _dictory.Add("this", "这");
            _dictory.Add("is", "是");
            _dictory.Add("an", "一个");
            _dictory.Add("apple", "苹果");
        }
        public static string GetEnglish(string value)
        {
            return _dictory[value];
        }
    }
}

将各部分解释器组合起来进行李包裹装,方便用户调用 Translator.cs

将各部分解释器组合起来举行打包,方便用户调用 Translator.cs

using System;
using System.Collections.Generic;
using System.Text;

namespace InterpreterPattern
{
    //将各部分解释器组合起来进行包装,方便用户调用。
    public static class Translator
    {
        public static string Translate(string sentense)
        {
            StringBuilder sb = new StringBuilder();
            List<IExpression> expressions = new List<IExpression>();
            string[] elements = sentense.Split(new char[] { '.' }, StringSplitOptions.RemoveEmptyEntries);
            foreach (string element in elements)
            {
                string[] words = element.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
                foreach (string word in words)
                {
                    expressions.Add(new WordExpression(word));
                }
                expressions.Add(new SymbolExpression("."));
            }
            foreach (IExpression expression in expressions)
            {
                expression.Interpret(sb);
            }                
            return sb.ToString();
        }
    }
}
using System;
using System.Collections.Generic;
using System.Text;

namespace InterpreterPattern
{
    //将各部分解释器组合起来进行包装,方便用户调用。
    public static class Translator
    {
        public static string Translate(string sentense)
        {
            StringBuilder sb = new StringBuilder();
            List<IExpression> expressions = new List<IExpression>();
            string[] elements = sentense.Split(new char[] { '.' }, StringSplitOptions.RemoveEmptyEntries);
            foreach (string element in elements)
            {
                string[] words = element.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
                foreach (string word in words)
                {
                    expressions.Add(new WordExpression(word));
                }
                expressions.Add(new SymbolExpression("."));
            }
            foreach (IExpression expression in expressions)
            {
                expression.Interpret(sb);
            }                
            return sb.ToString();
        }
    }
}

Client:客户类

Client:客户类

using System;

namespace InterpreterPattern
{
    class Program
    {
        static void Main(string[] args)
        {
            string englist = "This is an apple.";
            string chinese = Translator.Translate(englist);
            Console.WriteLine(chinese);
            Console.Read();
        }
    }
}
using System;

namespace InterpreterPattern
{
    class Program
    {
        static void Main(string[] args)
        {
            string englist = "This is an apple.";
            string chinese = Translator.Translate(englist);
            Console.WriteLine(chinese);
            Console.Read();
        }
    }
}

情势优缺点
解释器方式的独到之处
不难变动和增加文法。
简单落实文法。
追加了新的表达表明式的办法。
解释器方式的瑕疵
对此复散文法难以维护。
执行成效较低。
接纳场景很单薄。

格局优缺点
解释器情势的优点
不难变动和扩大文法。
不难落到实处文法。
追加了新的诠释表明式的方法。
解释器格局的败笔
对此复随笔法难以保证。
执行功用较低。
行使场景很简单。

形式适用条件
在以下情况下得以接纳解释器情势:
能够将3个亟需解释施行的语言中的句子表示为一个架空语法树。
一对重新出现的题材得以用一种简易的言语来拓展发挥。
文法较为简单。
频率不是关键难点。

格局适用条件
在偏下景况下能够运用解释器形式:
能够将三个索要表达施行的语言中的句子表示为多个华而不实语法树。
有的再一次出现的题材得以用一种简易的言语来开始展览发挥。
文法较为简单。
频率不是关键难点。

【证明与多谢】
正文,站在众多高个儿的肩膀上,借鉴和引用了不少客人拥有版权的创作或撰文,在此,对前人们的进献致谢。并还要发布引用的情节、原版的书文者或缘于(一些源于网络的始末小编不恐怕追述本源,深表遗憾)。

【注明与多谢】
正文,站在诸多高个子的双肩上,借鉴和引用了不少客人拥有版权的著述或撰文,在此,对前人们的进献致谢。并同时发布引用的始末、最初的著小编或出自(一些起点互连网的内容本人不能够追述本源,深表遗憾)。

【参考文献】
《设计形式—可复用面向对象软件的功底》小编: [美] 埃里克h Gamma / RichardHelm / 拉尔夫 Johnson / John Vlissides 译者: 李英军 / 马晓星 / 蔡敏 /
刘建中 等 机械工业出版社
《重构—革新既有代码的设计》小编: Martin Fowler译者:候捷
中国电力出版社
《敏捷软件开发—原则、方式与实践》小编: Robert C. 马丁 浙大东军事和政院学出版社
《程序员修炼之道—从小工到学者》小编: Andrew Hunt / 戴维 Thomas电子工业出版社
《Head First 设计方式》小编: Freeman 译者: O’Reilly Taiwan集团中华夏族民共和国电力出版社
《设计情势之禅》 小编: 秦小波 机械工业出版社
MSDN WebCast 《C#面向对象设计形式纵横谈》 教师:李建忠
刘伟(Liu-Wei). 设计方式. 新加坡:北大东军事和政院学出版社, 2012.
Liu Wei. 设计格局实验和培养和训练教程. 新加坡:南开东军事和政治高校学出版社, 二〇一二.
《大话设计方式》 作者: 程杰 北大高校出版社
《C#图解教程》小编: 索利斯 译者: 苏林 / 朱晔 人民邮政和邮电通讯出版社
《你无法不领悟的.NET》小编: 王涛
《项目中的.NET》小编: 李天平 电子工业出版社
《Microsoft .NET公司级应用架构划设想计》小编: (美)埃斯波西托等作品 译者:
陈黎夫
http://www.dofactory.com/Patterns/Patterns.aspx .NET Design Patterns
http://www.cnblogs.com/zhenyulu 博客小编:吕震宇
http://www.cnblogs.com/terrylee 博客作者:李会军
http://www.cnblogs.com/anlyren/ 博客作者:anlyren
http://www.cnblogs.com/idior 博客笔者:idior
http://www.cnblogs.com/allenlooplee 博客小编:Allen lee
http://blog.csdn.net/ai92 博客笔者:ai92
http://www.cnblogs.com/umlonline/ 博客我:张传波
http://www.cnblogs.com/lovecherry/ 博客小编:LoveCherry

【参考文献】
《设计情势—可复用面向对象软件的基础》小编: [美] 埃里克h Gamma / RichardHelm / 拉尔夫 Johnson / John Vlissides 译者: 李英军 / 马晓星 / 蔡敏 /
刘建中 等 机械工业出版社
《重构—改良既有代码的筹划》小编: 马丁 Fowler译者:候捷
中华夏族民共和国电力出版社
《敏捷软件开发—原则、形式与实施》我: 罗Bert C. 马丁 南开东军事和政院学出版社
《程序员修炼之道—从小工到学者》作者: Andrew Hunt / 戴维 Thomas电子工业出版社
《Head First 设计方式》我: Freeman 译者: O’Reilly Taiwan公司中中原人民共和国电力出版社
《设计情势之禅》 笔者: 秦小波 机械工业出版社
MSDN WebCast 《C#面向对象设计方式纵横谈》 助教:李建忠
刘伟(Liu-Wei). 设计格局. 新加坡:清华东军事和政院学出版社, 二零一三.
刘伟同志. 设计形式实验和培养和陶冶教程. 香港(Hong Kong):北大东军大学出版社, 二〇一二.
《大话设计情势》 作者: 程杰 复旦东军事和政院学出版社
《C#图解教程》小编: 索Liss 译者: 苏林 / 朱晔 人民邮电出版社
《你无法不掌握的.NET》笔者: 王涛
《项目中的.NET》小编: 李天平 电子工业出版社
《Microsoft .NET公司级应用架构划设想计》小编: (美)埃斯波西托等创作 译者:
陈黎夫
http://www.dofactory.com/Patterns/Patterns.aspx .NET Design Patterns
http://www.cnblogs.com/zhenyulu 博客小编:吕震宇
http://www.cnblogs.com/terrylee 博客小编:李会军
http://www.cnblogs.com/anlyren/ 博客小编:anlyren
http://www.cnblogs.com/idior 博客小编:idior
http://www.cnblogs.com/allenlooplee 博客小编:Allen lee
http://blog.csdn.net/ai92 博客作者:ai92
http://www.cnblogs.com/umlonline/ 博客我:张传波
http://www.cnblogs.com/lovecherry/ 博客笔者:LoveCherry

相关文章