Wzorzec projektowy interpreter

Stronę tą wyświetlono już: 2268 razy

Opis wzorca projektowego interpreter

Wzorzec projektowy interpreter należy do czynnościowych wzorców projektowych. Jego zadaniem jest podział zadań interpretacji składni prostych wyrażeń arytmetycznych. Główna klasa parsuje dane przygotowując je dla podklas np. w przypadku interpretacji wyrażenia matematycznego: 5+2.5*3+5/5-5 główna instancja interpretera sparsuje to wyrażenie do postaci listy:

  • 5
  • +
  • 2.5
  • *
  • 3
  • +
  • 5
  • /
  • 5
  • -
  • 5

Następnie poszczególne instancje klas wykonają działania:

  • mnożenia - względem operatora *
  • dzielenia - względem operatora /
  • dodawania - względem operatora +
  • odejmowania - względem operatora -

Przykładowy diagram UML wzorca projektowego interpreter

Użytkownik (program) tworzy instancję klasy Interpreter, która agreguje obiekty klas:

  • Multiply - odpowiedzialnej za realizację działania mnożenia;
  • Divide - odpowiedzialnej za realizację działania dzielenia;
  • Add - odpowiedzialnej za realizację działania dodawania;
  • Subtract - odpowiedzialnej za realizację działania odejmowania
Przykład diagramu UML dla wzorca projektowego interpreter
Rys. 1
Przykład diagramu UML dla wzorca projektowego interpreter

Przykład implementacji wzorca projektowego interpreter w C++

Listing 1
  1. #include <iostream>
  2. #include <string>
  3. #include <vector>
  5. const std::string operators("*/+-");
  7. class Multiply;
  8. class Divided;
  9. class Add;
  10. class Subtract;
  12. class Interpreter{
  13. protected:
  14. std::vector<std::string> equation;
  16. std::vector<std::string>::iterator findOperator(std::vector<std::string> &equation, std::string operatorName){
  17. for(std::vector<std::string>::iterator i = equation.begin(); i < equation.end(); i++){
  18. if((*i) == operatorName)
  19. return i;
  20. }
  21. return equation.end();
  22. }
  24. void parseString(std::string equation){
  25. std::string::size_type index = equation.find_first_of(operators);
  26. while(index != std::string::npos){
  27. if(index != 0){
  28. this->equation.push_back(equation.substr(0, index));
  29. equation.erase(0, index);
  30. }
  31. this->equation.push_back(equation.substr(0, 1));
  32. equation.erase(0, 1);
  33. index = equation.find_first_of(operators);
  34. }
  35. if(!equation.empty()){
  36. this->equation.push_back(equation);
  37. }
  38. }
  40. virtual void interprete(std::vector<std::string> & equation){}
  42. Interpreter* multiplyOperation;
  43. Interpreter* divideOperation;
  44. Interpreter* addOperation;
  45. Interpreter* subtractOperation;
  46. public:
  47. Interpreter(std::string equation);
  49. Interpreter(){
  50. multiplyOperation = divideOperation = addOperation = subtractOperation = NULL;
  51. }
  53. virtual ~Interpreter(){
  54. if(multiplyOperation){
  55. delete multiplyOperation;
  56. multiplyOperation = NULL;
  57. }
  58. if(divideOperation){
  59. delete divideOperation;
  60. divideOperation = NULL;
  61. }
  62. if(addOperation){
  63. delete addOperation;
  64. addOperation = NULL;
  65. }
  66. if(subtractOperation){
  67. delete subtractOperation;
  68. subtractOperation = NULL;
  69. }
  70. }
  71. };
  73. class Multiply : public Interpreter{
  74. protected:
  75. std::vector<std::string>::iterator findMultiplyOperator(std::vector<std::string> &equation){
  76. return findOperator(equation, "*");
  77. }
  79. std::string calculate(std::string left, std::string right){
  80. double l = atof(left.c_str());
  81. double r = atof(right.c_str());
  82. char value[100];
  83. gcvt(l * r, 10, value);
  84. return std::string(value);
  85. }
  87. virtual void interprete(std::vector<std::string> &equation){
  88. std::vector<std::string>::iterator operatorPointer = findMultiplyOperator(equation);
  90. while(operatorPointer != equation.end()){
  91. int pos = (int)(operatorPointer - equation.begin());
  92. std::string value = calculate(*(operatorPointer - 1), *(operatorPointer + 1));
  93. equation.insert(operatorPointer - 1, value);
  94. equation.erase(equation.begin() + pos, equation.begin() + pos + 3);
  95. operatorPointer = findMultiplyOperator(equation);
  96. }
  97. }
  98. };
  100. class Divide : public Interpreter{
  101. protected:
  102. std::vector<std::string>::iterator findDivideOperator(std::vector<std::string> &equation){
  103. return findOperator(equation, "/");
  104. }
  106. std::string calculate(std::string left, std::string right){
  107. double l = atof(left.c_str());
  108. double r = atof(right.c_str());
  109. char value[100];
  110. gcvt(l / r, 10, value);
  111. return std::string(value);
  112. }
  114. virtual void interprete(std::vector<std::string> &equation){
  115. std::vector<std::string>::iterator operatorPointer = findDivideOperator(equation);
  117. while(operatorPointer != equation.end()){
  118. int pos = (int)(operatorPointer - equation.begin());
  119. std::string value = calculate(*(operatorPointer - 1), *(operatorPointer + 1));
  120. equation.insert(operatorPointer - 1, value);
  121. equation.erase(equation.begin() + pos, equation.begin() + pos + 3);
  122. operatorPointer = findDivideOperator(equation);
  123. }
  124. }
  125. };
  127. class Add : public Interpreter{
  128. protected:
  129. std::vector<std::string>::iterator findAddOperator(std::vector<std::string> &equation){
  130. return findOperator(equation, "+");
  131. }
  133. std::string calculate(std::string left, std::string right){
  134. double l = atof(left.c_str());
  135. double r = atof(right.c_str());
  136. char value[100];
  137. gcvt(l + r, 10, value);
  138. return std::string(value);
  139. }
  141. virtual void interprete(std::vector<std::string> &equation){
  142. std::vector<std::string>::iterator operatorPointer = findAddOperator(equation);
  144. while(operatorPointer != equation.end()){
  145. int pos = (int)(operatorPointer - equation.begin());
  146. std::string value = calculate(*(operatorPointer - 1), *(operatorPointer + 1));
  147. equation.insert(operatorPointer - 1, value);
  148. equation.erase(equation.begin() + pos, equation.begin() + pos + 3);
  149. operatorPointer = findAddOperator(equation);
  150. }
  151. }
  152. };
  154. class Subtract : public Interpreter{
  155. protected:
  156. std::vector<std::string>::iterator findSubtractOperator(std::vector<std::string> &equation){
  157. return findOperator(equation, "-");
  158. }
  160. std::string calculate(std::string left, std::string right){
  161. double l = atof(left.c_str());
  162. double r = atof(right.c_str());
  163. char value[100];
  164. gcvt(l - r, 10, value);
  165. return std::string(value);
  166. }
  168. virtual void interprete(std::vector<std::string> &equation){
  169. std::vector<std::string>::iterator operatorPointer = findSubtractOperator(equation);
  171. while(operatorPointer != equation.end()){
  172. int pos = (int)(operatorPointer - equation.begin());
  173. std::string value = calculate(*(operatorPointer - 1), *(operatorPointer + 1));
  174. equation.insert(operatorPointer - 1, value);
  175. equation.erase(equation.begin() + pos, equation.begin() + pos + 3);
  176. operatorPointer = findSubtractOperator(equation);
  177. }
  178. }
  179. };
  181. int main(){
  183. Interpreter interpreter("5+2.5*3+5/5-5");
  185. std::cin.get();
  186. return 0;
  187. }
  189. Interpreter::Interpreter(std::string equation){
  190. std::cout << "Parse equation: " << equation << std::endl;
  192. parseString(equation);
  194. for(std::vector<std::string>::iterator i = this->equation.begin(); i < this->equation.end(); i++){
  195. std::cout << *i << std::endl;
  196. }
  198. multiplyOperation = new Multiply;
  199. multiplyOperation->interprete(this->equation);
  201. std::cout << "After multiply:" << std::endl;
  203. for(std::vector<std::string>::iterator i = this->equation.begin(); i < this->equation.end(); i++){
  204. std::cout << *i << std::endl;
  205. }
  207. divideOperation = new Divide;
  208. divideOperation->interprete(this->equation);
  210. std::cout << "After divided:" << std::endl;
  212. for(std::vector<std::string>::iterator i = this->equation.begin(); i < this->equation.end(); i++){
  213. std::cout << *i << std::endl;
  214. }
  216. divideOperation = new Add;
  217. divideOperation->interprete(this->equation);
  219. std::cout << "After added:" << std::endl;
  221. for(std::vector<std::string>::iterator i = this->equation.begin(); i < this->equation.end(); i++){
  222. std::cout << *i << std::endl;
  223. }
  225. subtractOperation = new Subtract;
  226. subtractOperation->interprete(this->equation);
  228. std::cout << "Calculated:" << std::endl;
  230. for(std::vector<std::string>::iterator i = this->equation.begin(); i < this->equation.end(); i++){
  231. std::cout << *i << std::endl;
  232. }
  234. }

Wynik działania powyższego kodu:

Parse equation: 5+2.5*3+5/5-5
5
+
2.5
*
3
+
5
/
5
-
5
After multiply:
5
+
7.5
+
5
/
5
-
5
After divided:
5
+
7.5
+
1.
-
5
After added:
13.5
-
5
Calculated:
8.5
Strony powiązane
strony powiązane
  1. sourcemaking.com/design_patterns/interpreter - strona opisująca wzorzec projektowy interpreter [En]
  2. pl.wikipedia.org - opis tego wzorca na stronie Wikipedii
Propozycje książek
tytuł: Wzorce projektowe w .NET Core 3. Projektowanie zorientowane obiektowo z wykorzystaniem C# i F# autor: Dmitri Nesteruk

Tytuł:

Wzorce projektowe w .NET Core 3. Projektowanie zorientowane obiektowo z wykorzystaniem C# i F#

Autor:

Dmitri Nesteruk

tytuł: Wzorce projektowe. Elementy oprogramowania obiektowego wielokrotnego użytku autor: Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides

Tytuł:

Wzorce projektowe. Elementy oprogramowania obiektowego wielokrotnego użytku

Autor:

Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides

tytuł: Projektowanie interfejsów., Sprawdzone wzorce projektowe. Wydanie III autor: Jenifer Tidwell, Charles Brewer, Aynne Valencia-Brooks

Tytuł:

Projektowanie interfejsów., Sprawdzone wzorce projektowe. Wydanie III

Autor:

Jenifer Tidwell, Charles Brewer, Aynne Valencia-Brooks

tytuł: Kubernetes. Wzorce projektowe. Komponenty wielokrotnego użycia do projektowania natywnych aplikacji chmurowych autor: Bilgin Ibryam, Roland Huß

Tytuł:

Kubernetes. Wzorce projektowe. Komponenty wielokrotnego użycia do projektowania natywnych aplikacji chmurowych

Autor:

Bilgin Ibryam, Roland Huß

tytuł: Wzorce projektowe w .NET. Projektowanie zorientowane obiektowo z wykorzystaniem C# i F# autor: Dmitri Nesteruk

Tytuł:

Wzorce projektowe w .NET. Projektowanie zorientowane obiektowo z wykorzystaniem C# i F#

Autor:

Dmitri Nesteruk

tytuł: Programowanie zorientowane obiektowo. Wzorce projektowe. Wydanie II autor: Alan Shalloway, James R. Trott

Tytuł:

Programowanie zorientowane obiektowo. Wzorce projektowe. Wydanie II

Autor:

Alan Shalloway, James R. Trott

tytuł: Java EE 8. Wzorce projektowe i najlepsze praktyki autor: Rhuan Rocha, Joao Purificacao

Tytuł:

Java EE 8. Wzorce projektowe i najlepsze praktyki

Autor:

Rhuan Rocha, Joao Purificacao

tytuł: Systemy reaktywne. Wzorce projektowe i ich stosowanie autor: Roland Kuhn Dr., Brian Hanafee, Jamie Allen

Tytuł:

Systemy reaktywne. Wzorce projektowe i ich stosowanie

Autor:

Roland Kuhn Dr., Brian Hanafee, Jamie Allen

tytuł: Adaptywny kod. Zwinne programowanie, wzorce projektowe i SOLID-ne zasady. Wydanie II autor: Gary McLean Hall

Tytuł:

Adaptywny kod. Zwinne programowanie, wzorce projektowe i SOLID-ne zasady. Wydanie II

Autor:

Gary McLean Hall

tytuł: Wzorce projektowe. Leksykon kieszonkowy autor: Daniel Krasnokucki

Tytuł:

Wzorce projektowe. Leksykon kieszonkowy

Autor:

Daniel Krasnokucki

Komentarze