16 interpreter mode

Reprint of the original ：https://blog.csdn.net/sinat_21107433/article/details/102864850

seen 《 Ming Dynasty 1566》 Do you ？ This is a Jungle The most favorite and respected historical drama I have ever seen . All the friends who have seen this play know , Emperor Jiajing never spoke out clearly , But like to talk around , Or a code word , If you don't speculate carefully , I don't know what the real meaning of Jiajing's words is . For example, he told Chen Hong “ Go to the water limit , Sit and watch the clouds rise ”, Chen Hong thought that he would come to the emperor to weed ; The crown prince has a son , Jiajing gave jujubes and chestnuts …… If Jungle Living at that time , The skull is really getting bigger , It's enough to speculate about the emperor's intentions all day . If only there were an interpreter , Be able to interpret the emperor's words as plain language ！

1. An overview of interpreter patterns

The Interpreter pattern is used to describe a simple language interpreter , It is mainly applied to the design of the interpreter developed with object-oriented language . When it comes to developing a new language , You can use interpreter mode .

Interpreter mode ：

Given a language , A representation of the grammar that defines it , And define an interpreter , This interpreter uses this representation to interpret sentences in a language .

What the Interpreter pattern needs to solve is , If a particular type of problem occurs frequently enough , Then it may be worth expressing each instance of the problem as a sentence in a simple language . In this way, you can construct an interpreter , The interpreter interprets these sentences , To solve the problem . The Interpreter pattern describes how to define a grammar for a simple language , How to express a sentence in the language , And how to explain these sentences .

2. Interpreter pattern structure

The structure of the Interpreter pattern consists of abstract expressions 、 Terminator expression 、 Nonterminal expressions and environment classes make up ：

• AbstractExpression（ Abstract expression ）： Declare an abstract interpretation operation interpret(), Is the base class for all terminator and non terminator expressions ;
• TerminalExpression（ Terminator expression ）： Terminator is the most basic language unit in the constituent elements of grammar rules , It can't be broken down . The terminator expression implements the interpretation operations related to the terminator in the grammar rules , Each terminator in a sentence is an instance of this class .
• NonterminalExpression（ Nonterminal expression ）： It realizes the interpretation operation of non terminator in grammar rules , Because non terminator expressions can also contain terminator expressions , So a terminator expression can be a member of a non terminator expression .
• Context（ The environment class ）： Context class , Used to store some global information outside the interpreter , Usually temporarily store statements that need to be interpreted .

Interpreter mode UML As shown above . Abstract expressions declare abstract interfaces interpret(), Terminator expressions and non terminator expressions implement the interface . among , Of the terminator expression interpret() The interface implements specific interpretation operations , and A non terminal expression may contain a terminal expression or a non terminal expression , So the expression of non Terminator interpret() The interface may call each component recursively interpret() Method . 

3. Interpreter pattern code example

In this section, Jungle Use the Interpreter pattern to implement the following small function ：

Design a simple interpreter , So that the system can explain 0 and 1 Or operation and and operation （ Regardless of the priority of or operation and and operation , That is, from left to right ）, Several examples of statement expressions and output results are shown in the following table ：

Example table of expression and output results

expression	Output results	expression	Output results
1 and 1	1	0 or 0	0
1 or 1	1	1 and 1 or 0	1
1 or 0	1	0 or 1 and 0	0
1 and 0	0	0 or 1 and 1 or 1	1
0 and 0	0	1 or 0 and 1 and 0 or 0	0

Combined with the structure of the interpreter mode described above and this example , The following roles can be divided ：

• Terminator expression role —— Value node （ValueNode）：0、1, Because they are the basic elements of expressions , It can't be subdivided
• Terminator expression role —— Operator node （OperatorNode）： Operation symbol “and” and “or” , It is also the basic element of an expression
• Nonterminal expression role —— Sentence nodes （SentenceNode）： Be similar to “1 and 1” Such an expression or a longer combined expression
• Context class roles —— handler （Handler）： Save the input expression and the output result

thus , In this case UML The example is as follows ：

3.1. Abstract expression

1. // Abstract expression class

2. class AbstractNode

3. {

4. public:

5. AbstractNode(){}

6. // Declare abstract interfaces

7. virtual char interpret() = 0;

8. };

3.2. Terminator expression role —— Value node

1. // Terminator expression ：ValueNode

2. class ValueNode :public AbstractNode

3. {

4. public :

5. ValueNode(){}

6. ValueNode(int iValue){

7. this->value = iValue;

8. }

9. // Implementation of interpretation operations

10. char interpret(){

11. return value;

12. }

13. private:

14. int value;

15. };

3.3. Terminator expression role —— Operator node

1. // Terminator expression ：OperationNode

2. class OperatorNode :public AbstractNode

3. {

4. public:

5. OperatorNode(){}

6. OperatorNode(string iOp){

7. this->op = iOp;

8. }

9. // Implementation of interpretation operations

10. char interpret(){

11. if (op == "and"){

12. return '&';

13. }

14. else if (op == "or"){

15. return '|';

16. }

17. return 0;

18. }

19. private:

20. string op;

21. };

3.4. Nonterminal expression role —— Sentence nodes

Each sentence node consists of “ Lvalue node + Operator node + Right value node ” form .

1. // Nonterminal expression ：SentenceNode

2. class SentenceNode :public AbstractNode

3. {

4. public:

5. SentenceNode(){}

6. SentenceNode(AbstractNode *iLeftNode,

7. AbstractNode *iRightNode, AbstractNode* iOperatorNode){

8. this->leftNode = iLeftNode;

9. this->rightNode = iRightNode;

10. this->operatorNode = iOperatorNode;

11. }

12. char interpret(){

13. if (operatorNode->interpret() == '&'){

14. return leftNode->interpret()&rightNode->interpret();

15. }

16. else{

17. return leftNode->interpret()|rightNode->interpret();

18. }

19. return 0;

20. }

21. private:

22. AbstractNode *leftNode;

23. AbstractNode *rightNode;

24. AbstractNode *operatorNode;

25. };

3.5. Contextual roles —— handler

The processor will process the input expression , And explain the final result of the expression .

1. // handler

2. class Handler

3. {

4. public:

5. Handler(){}

6. void setInput(string iInput){

7. this->input = iInput;

8. }

9. void handle(){

10. AbstractNode *left = NULL;

11. AbstractNode *right = NULL;

12. AbstractNode *op = NULL;

13. AbstractNode *sentence = NULL;

14. string iInput = this->input;

15. vector<string>inputList;

16. char* inputCh = const_cast<char*>(iInput.c_str());

17. char *token = strtok(inputCh, " ");

18. while (token != NULL){

19. inputList.push_back(token);

20. token = strtok(NULL, " ");

21. }

22. for (int i = 0; i < inputList.size() - 2; i += 2){

23. left = new ValueNode(*(inputList[i].c_str()));

24. op = new OperatorNode(inputList[i + 1]);

25. right = new ValueNode(*(inputList[i+2].c_str()));

26. sentence = new SentenceNode(left, right, op);

27. inputList[i + 2] = string(1, sentence->interpret());

28. }

29. string tmpRes = inputList[inputList.size() - 1];

30. if (tmpRes == "1"){

31. result = 1;

32. }

33. else if (tmpRes == "0"){

34. result = 0;

35. }

36. else{

37. result = -1;

38. }

39. this->output();

40. }

41. void output(){

42. printf("%s = %d\n", input.c_str(), result);

43. }

44. private:

45. string input;

46. char result;

47. };

3.6. Client code examples and results  

1. #include <iostream>

2. #include "InterpreterPattern.h"

3.  

4. int main()

5. {

6. Handler *handler = new Handler();

7.  

8. string input_1 = "1 and 1";

9. string input_2 = "1 and 0";

10. string input_3 = "0 and 1";

11. string input_4 = "0 and 0";

12. string input_5 = "0 or 0";

13. string input_6 = "0 or 1";

14. string input_7 = "1 or 0";

15. string input_8 = "1 or 1";

16. string input_9 = "1 and 0 or 1";

17. string input_10 = "0 or 0 and 1";

18. string input_11 = "1 or 1 and 1 and 0";

19. string input_12 = "0 and 1 and 1 and 1";

20. string input_13 = "0 and 1 and 1 and 1 or 1 or 0 and 1";

21. handler->setInput(input_1); handler->handle();

22. handler->setInput(input_2); handler->handle();

23. handler->setInput(input_3); handler->handle();

24. handler->setInput(input_4); handler->handle();

25. handler->setInput(input_5); handler->handle();

26. handler->setInput(input_6); handler->handle();

27. handler->setInput(input_7); handler->handle();

28. handler->setInput(input_8); handler->handle();

29. handler->setInput(input_9); handler->handle();

30. handler->setInput(input_10); handler->handle();

31. handler->setInput(input_11); handler->handle();

32. handler->setInput(input_12); handler->handle();

33. handler->setInput(input_13); handler->handle();

34.  

35. printf("\n\n");

36. system("pause");

37. return 0;

38. }

The operation results are as follows ：

 4. summary

advantage ：

• Easy to change and expand the grammar , Use classes in the interpreter to represent the grammar rules of the language , The grammar can be changed or extended through mechanism classes such as inheritance ;
• Each provision can be represented as a class , So it's easy to implement a simple language ;
• If you want to add a new interpretation expression , Just add a new terminator expression or non terminator expression class , There is no need to change the original code , Comply with opening and closing principle .

shortcoming ：

• Complex grammars are difficult to maintain . In the Interpreter pattern, each rule needs to define at least one class , So if a language contains too many rules of grammar , The number of classes will increase significantly , This makes the system difficult to manage and maintain ;
• Inefficient execution , Because there are a lot of loops and recursive calls in the Interpreter pattern .

Apply to the environment ：

• Some recurring problems can be expressed in a simple language ;
• The grammar of a language is relatively simple ;
• The interpreter mode can be used regardless of execution efficiency .