该解释器通过解释那几个句子来解决那么些难点,本文已添加至索引

方式动机
图片 1

形式动机
图片 2

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

只要在系统中某一一定类型的难点发生的频率很高,此时得以考虑将那一个题材的实例表述为3个语言中的句子,由此得以营造三个解释器,该解释器通过解释那么些句子来化解那几个题材。
解释器形式描述了何等整合1个大概的语言解释器,重要使用在动用面向对象语言开发的编写翻译器中。

若果在系统中某一特定类型的标题产生的作用很高,此时得以设想将那一个难点的实例表述为一个言语中的句子,因此得以创设一个解释器,该解释器通过解释那么些句子来解决这一个难点。
解释器格局描述了怎么着结合一个简易的语言解释器,重要行使在动用面向对象语言开发的编写翻译器中。

设计格局

### 学习笔记索引

格局定义
解释器形式(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效能

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

适用情况

  • 当有二个言语供给解释施行,
    并且大家可将该语言中的句子表示为三个泛泛语法树时,可利用解释器情势。当存在以下情形时,效果最好:

    • 该文法简单。对于复杂的文法, 文法的类层次变得高大而望洋兴叹管理
    • 频率不是三个关键难点。最便捷的解释器经常不是经过一贯表明语法分析树实现。

插手部分

  • AbstractExpression(抽象表达式):声美素佳儿(Friso)个空洞的表达操作,这一个接口为架空语法树中有所的节点所共享
  • TerminalExpression(终结符表达式):完成与文法中的终结符相关联的诠释操作,叁个句子中的每一个终结符须要该类的1个实例
  • NonterminalExpression(非终结符表明式):为文法中的非终结符达成解释操作。解释时,一般要递归调用它所保证的AbstractExpression类型对象的分解操作
  • Context(上下文):包括解释器之外的一部分大局信息
  • Client(用户):营造(或被给定)
    表示该文法定义的言语中三个一定的语句的肤浅语法树。该抽象语法树由TerminalExpression和NonterminalExpression的实例装配而成。

合营进度

  • Client构建叁个句子,它是TerminalExpression和NonterminalExpression的实例的一个虚幻语法树,然后初阶化上下文,并调用解释操作。
  • 每一非终结符表达式节点定义相应子表明式的分解操作。
  • 每一节点的演说操成效上下文来囤积和做客解释器的意况。

UML图

图片 7

形式分析
解释器形式描述了什么样为简易的语言定义贰个文法,如何在该语言中代表1个句子,以及怎么着解释这一个句子。
文法规则实例:
expression ::= value | symbol
symbol ::= expression ‘+’ expression | expression ‘-‘ expression
value ::= an integer //二个整数值
在文法规则定义中得以行使部分标志来表示不相同的含义,如选用“|”表示或,使用“{”和“}”表示结合,使用“*”表示出现0次或频仍等,个中使用频率最高的标志是意味着或关系的“|”

方式分析
解释器方式描述了怎么样为简便的语言定义一个文法,怎么样在该语言中意味2个句子,以及怎么样分解那么些句子。
文法规则实例:
expression ::= value | symbol
symbol ::= expression ‘+’ expression | expression ‘-‘ expression
value ::= an integer //贰个整数值
在文法规则定义中得以选用一些标志来表示分歧的意义,如使用“|”表示或,使用“{”和“}”表示结合,使用“*”表示出现0次或频繁等,个中使用频率最高的记号是意味或涉嫌的“|”

示范分析 – 字符画解释器

为了让MM不明觉厉,我想开了通过简单的解释器来促成,从字符串到三个字符画的转移进度。小编认为使用stringstream流能够便宜地营造一个字符画,由此,大家率先分明大家贯彻那一个形式的上下文(Context)正是stringstream对象。然后大家定义一些现实的字符操作表明式。它们是能够画出字符画的部分基本操作:

TerminalExpression:

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

NonterminalExpression:

  • RepeatExpression:重复表明式。它是非终结符表明式。它的解释操作正是使三个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

到了此地,大家只要想生成2个字符画: “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 }

这便是说大家输入在此之前第一串字符试试:

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

MM表示很如沐春风。对于这一个示例的UML图:

图片 16

空泛语法树:
除开选择文法规则来定义一个语言,在解释器情势中还能通过一种名叫抽象语法树(Abstract
Syntax Tree,
AST)的图样方式来直观地意味着语言的构成,每一棵抽象语法树对应多少个言语实例。
图片 17

空洞语法树:
而外运用文法规则来定义三个语言,在解释器情势中还足以因此一种名叫抽象语法树(Abstract
Syntax Tree,
AST)的图形格局来直观地球表面示语言的结缘,每一棵抽象语法树对应3个言语实例。
图片 18

特征总结

作者们可以见到,Interpreter解释器形式有以下优点和短处:

  1. 不难变动和扩充文法。因为该形式选用类来代表文法规则,大家得以利用持续来改变或扩张该文法。多加一种文法就新增2个类。
  2. 也易于落到实处文法。定义抽象语法树中逐一节点的类的兑现大体类似。日常它们也可用二个编写翻译器或语法分析程序生成器自动生成。
  3. 复杂的文法难以保险。解释器形式为文法中的每一条规则至少定义了三个类,由此包括众多规则的文法大概麻烦管理和掩护。

再正是大家能够旁观,它和任何设计形式:Composite(组合)模式持有广大相通的地点。具体能够参见之前的笔记。

抽象语法树描述了怎么着整合2个错综复杂的句子,通过对抽象语法树的剖析,能够辨认出语言中的终结符和非终结符类。
在解释器方式中,每一个终结符和非终结符都有3个具体类与之相应,正因为运用类来代表每四个语法规则,使得系统具备较好的扩充性和灵活性。

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

写在最后

今天的笔记就到这边了,欢迎大家批评指正!如若认为能够的话,好文推荐一晃儿,小编会相当多谢的!

方式实例与分析
以中国和英国文翻译系统为例来介绍解释器形式
系统布局
图片 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();
        }
    }
}

情势优缺点
解释器方式的帮助和益处
简单变动和壮大文法。
简单落实文法。
日增了新的解释表明式的办法。
解释器方式的弱点
对此复诗歌法难以保险。
履行功效较低。
选用场景很有限。

形式优缺点
解释器方式的长处
简单变动和扩充文法。
不难落到实处文法。
扩张了新的演讲说明式的措施。
解释器格局的败笔
对于复随想法难以有限支撑。
施行效用较低。
选取场景很单薄。

格局适用条件
在偏下景况下得以选择解释器格局:
能够将二个亟待解释施行的言语中的句子表示为二个华而不实语法树。
有的双重出现的难题得以用一种简易的言语来进行发挥。
文法较为简单。
频率不是关键难题。

格局适用条件
在以下情形下得以采纳解释器情势:
能够将叁个亟需解释施行的言语中的句子表示为二个空洞语法树。
一些重复现身的题材能够用一种简单的语言来举办表述。
文法较为简单。
频率不是关键难点。

【注解与谢谢】
本文,站在不少壮汉的双肩上,借鉴和引用了好多旁人拥有版权的小说或撰文,在此,对前人们的贡献致谢。并同时发布引用的始末、原小编或出自(一些来自网络的内容本身不可能追述本源,深表遗憾)。

【注明与感激】
本文,站在重重高个子的肩头上,借鉴和引用了广大别人拥有版权的小说或撰文,在此,对前人们的贡献致谢。并还要发布引用的始末、原笔者或出自(一些起点网络的内容自个儿无法追述本源,深表遗憾)。

【参考文献】
《设计方式—可复用面向对象软件的底子》笔者: [美] 埃里克h Gamma / RichardHelm / 拉尔夫 Johnson / John Vlissides 译者: 李英军 / 马晓星 / 蔡敏 /
刘建中 等 机械工业出版社
《重构—改良既有代码的安顿性》我: 马丁 Fowler译者:候捷
中华夏族民共和国电力出版社
《敏捷软件开发—原则、方式与实施》笔者: 罗Bert C. 马丁 浙大东军事和政院学出版社
《程序员修炼之道—从小工到大方》小编: Andrew Hunt / 大卫 托马斯电子工业出版社
《Head First 设计格局》小编: Freeman 译者: O’Reilly Taiwan公司中夏族民共和国电力出版社
《设计形式之禅》 小编: 秦小波 机械工业出版社
MSDN WebCast 《C#面向对象设计方式纵横谈》 教授:李建忠
刘伟(Liu-Wei). 设计情势. 上海:南开东军大学出版社, 2012.
Liu Wei. 设计格局实验和培养和锻练教程. 新加坡:北大东军事和政治高校学出版社, 二零一三.
《大话设计方式》 作者: 程杰 北大东军大学出版社
《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 博客作者:阿伦 lee
http://blog.csdn.net/ai92 博客小编:ai92
http://www.cnblogs.com/umlonline/ 博客小编:张传波
http://www.cnblogs.com/lovecherry/ 博客小编:LoveCherry

【参考文献】
《设计形式—可复用面向对象软件的底蕴》小编: [美] Erich Gamma / 理查德Helm / 拉尔夫 Johnson / 约翰 Vlissides 译者: 李英军 / 马晓星 / 蔡敏 /
刘建中 等 机械工业出版社
《重构—革新既有代码的安顿性》小编: 马丁 Fowler译者:候捷
中中原人民共和国电力出版社
《敏捷软件开发—原则、格局与执行》作者: 罗Bert C. 马丁 南开东军事和政院学出版社
《程序员修炼之道—从小工到学者》小编: Andrew Hunt / 大卫 托马斯电子工业出版社
《Head First 设计情势》笔者: Freeman 译者: O’Reilly Taiwan公司中中原人民共和国电力出版社
《设计方式之禅》 我: 秦小波 机械工业出版社
MSDN WebCast 《C#面向对象设计情势纵横谈》 教师:李建忠
刘伟先生. 设计形式. 新加坡:南开东军事和政院学出版社, 2013.
刘伟先生. 设计情势实验和培养和陶冶教程. 新加坡:哈工业余大学学东军大学出版社, 二零一一.
《大话设计形式》 笔者: 程杰 浙大东军事和政院学出版社
《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

相关文章