定义

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

类型

行为型模式

案例

像很熟知的正則表達式就是描写叙述字符串模式的一种标准语言，它为每个模式都构造了一个特定的算法。

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. }
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. }
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. }
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. }
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!