现在的位置: 首页 > 综合 > 正文

有限状态机(FSM)——《C++编程风格》读书笔记（六） 有限状态机(FSM)——《C++编程风格》读书笔记（六）

2017年11月05日 ⁄ 综合 ⁄ 共 21706字 ⁄ 字号 小 中 大 ⁄ 评论关闭
 

有限状态机(FSM)——《C++编程风格》读书笔记（六）

分类： 读书笔记2010-03-03
22:43 4191人阅读 评论(9) 收藏 举报
编程读书c++transitioninputstruct

      这章主要研究的是一个有限状态机(finite state machine),简称FSM。当其获得一个字符时，FSM将发生转换，即从当前状态转换到另一状态。有限状态机(FSM)是一种抽象的机制，他在任意时刻都处以有限状态集合中的某一个状态。

 

    我们研究的一个FSM的转换规则是（不能上图，口述下）： {1,'A',2},{1,'B',3},{1,'C',4},{1,'D',5},{2,'E',2},{2,'I',0},{3,'F',3},{3,'J',0},{3,'M',4},{4,'G',4},{4,'K',0},{5,'H',5},{5,'L',0},{5,'O',2},{5,'N',4},{0,0,0}，即在开始状态1时：输入A到状态2，B到状态3，0为结束状态。程序的目的是判断一个字符串是否能在FSM下由开始状态走到结束状态。

 

                                                   程序1 最初的FSM程序

[cpp] view
plaincopy

  1. #include <string.h>  
  2. #include <stdio.h>  
  3.   
  4. struct parent  
  5. {  
  6.     static char* expression;  
  7.     static int index;  
  8.     static int end_state;  
  9.     static int doom_state;  
  10.   
  11.     parent(char* expr);  
  12.     virtual parent* transition() {}  
  13. };  
  14.   
  15. parent::parent(char* expr)  
  16. {  
  17.     expression = new char[strlen(expr)];  
  18.     strcpy(expression,expr);  
  19.     end_state = 0;  
  20.     doom_state = 0;  
  21.     index = 0;  
  22. }  
  23.   
  24. struct state1:public parent  
  25. {  
  26.     parent *ptr2,*ptr3,*ptr4,*ptr5;  
  27.     state1():parent(expression) {}  
  28.     parent* transition();  
  29. };  
  30.   
  31. struct state2:public parent  
  32. {  
  33.     parent *ptr2;  
  34.     state2():parent(expression) {}  
  35.     parent* transition();  
  36. };  
  37.   
  38. struct state3:public parent  
  39. {  
  40.     parent *ptr3,*ptr4;  
  41.     state3():parent(expression) {}  
  42.     parent* transition();  
  43. };  
  44.   
  45. struct state4:public parent  
  46. {  
  47.     parent *ptr4;  
  48.     state4():parent(expression) {}  
  49.     parent* transition();  
  50. };  
  51.   
  52. struct state5:public parent  
  53. {  
  54.     parent *ptr2,*ptr4,*ptr5;  
  55.     state5():parent(expression) {}  
  56.     parent* transition();  
  57. };  
  58.   
  59. parent* state1::transition()  
  60. {  
  61.     switch(expression[index++])  
  62.     {  
  63.         case 'A':  
  64.             return ptr2;  
  65.         case 'B':  
  66.             return ptr3;  
  67.         case 'C':  
  68.             return ptr4;  
  69.         case 'D':  
  70.             return ptr5;  
  71.         case '/0':  
  72.             doom_state = 1;  
  73.         default:  
  74.             doom_state = 1;  
  75.     }  
  76. }  
  77.   
  78. parent* state2::transition()  
  79. {  
  80.     switch(expression[index++])  
  81.     {  
  82.         case 'E':  
  83.             return ptr2;  
  84.         case 'I':  
  85.             end_state = 1;  
  86.             break;  
  87.         case '/0':  
  88.             doom_state = 1;  
  89.         default:  
  90.             doom_state = 1;  
  91.     }  
  92. }  
  93.   
  94. parent* state3::transition()  
  95. {  
  96.     switch(expression[index++])  
  97.     {  
  98.         case 'F':  
  99.             return ptr3;  
  100.         case 'M':  
  101.             return ptr4;  
  102.         case 'J':  
  103.             end_state = 1;  
  104.             break;  
  105.         case '/0':  
  106.             doom_state = 1;  
  107.         default:  
  108.             doom_state = 1;  
  109.     }  
  110. }  
  111.   
  112. parent* state4::transition()  
  113. {  
  114.     switch(expression[index++])  
  115.     {  
  116.         case 'G':  
  117.             return ptr4;  
  118.         case 'K':  
  119.             end_state = 1;  
  120.             break;  
  121.         case '/0':  
  122.             doom_state = 1;  
  123.         default:  
  124.             doom_state = 1;  
  125.     }  
  126. }  
  127.   
  128. parent* state5::transition()  
  129. {  
  130.     switch(expression[index++])  
  131.     {  
  132.         case 'O':  
  133.             return ptr2;  
  134.         case 'H':  
  135.             return ptr5;  
  136.         case 'L':  
  137.             end_state = 1;  
  138.             break;  
  139.         case 'N':  
  140.             return ptr4;  
  141.         case '/0':  
  142.             doom_state = 1;  
  143.         default:  
  144.             doom_state = 1;  
  145.     }  
  146. }  
  147.   
  148. char* parent::expression = NULL;  
  149. int parent::doom_state = 0;  
  150. int parent::end_state = 0;  
  151. int parent::index = 0;  
  152.   
  153. state1 s1;  
  154. state2 s2;  
  155. state3 s3;  
  156. state4 s4;  
  157. state5 s5;  
  158.   
  159. void build_state_machine()  
  160. {  
  161.     s1.ptr2 = &s2;  
  162.     s1.ptr3 = &s3;  
  163.     s1.ptr4 = &s4;  
  164.     s1.ptr5 = &s5;  
  165.     s2.ptr2 = &s2;  
  166.     s3.ptr3 = &s3;  
  167.     s3.ptr4 = &s4;  
  168.     s4.ptr4 = &s4;  
  169.     s5.ptr2 = &s2;  
  170.     s5.ptr4 = &s4;  
  171.     s5.ptr5 = &s5;  
  172. }  
  173.   
  174. int main()  
  175. {  
  176.     build_state_machine();  
  177.     char input_string[80];  
  178.     printf("Enter input expression: ");  
  179.     scanf("%s",input_string);  
  180.     parent state_machine(input_string);  
  181.     parent *ptr;  
  182.     ptr = s1.transition();  
  183.     while(ptr->end_state !=1 && ptr->doom_state != 1)  
  184.     {  
  185.         ptr = ptr->transition();  
  186.     }  
  187.     if(ptr->end_state == 1)  
  188.         printf("/nValid input expression");  
  189.     else  
  190.         printf("/nInvalid input expression");  
  191.   
  192.     return 0;  
  193. }  

 

程序分析：

  1. expression = new char[strlen(expr)];这句中字符串后应该有空格存在，应加1.
  2. 依照执行顺序，最开始执行的是全局对象s1到s5的构造函数。s1的构造函数执行后expression将指向动态开辟的内存的地址，s2执行时，expression又指向另一新开辟内存，原理开辟的内存成为垃圾内存，形成内存泄露。
  3. s1构造完后，本身的地址值是不变的，因而可用&s1代替ptr1等等。
  4. 程序中对state_machine的使用仅仅是为了执行它的构造函数，将FSM重置为初始状态。而将FSM重置为初始状态并不是初始化。FSM是一组静态变量。我们应该使用静态成员函数将FSM重置为起始状态。原则：不要使用构造函数来初始化静态数据成员。

基于上面的分析，做如下改动：

 

  1. 用静态成员函数来reset()代替parent的构造函数。
  2. 改正缺1错误。
  3. 从main()中去掉state_machine，并直接调用parent::reset()。
  4. 去掉每个statej的构造函数。
  5. 去掉statej::ptri成员，并用&si代替。
  6. 去掉build_state_machine()。

 

                                                  程序2 用reset()来代替parent::parent()

 

[cpp] view
plaincopy

  1. #include <string.h>  
  2. #include <stdio.h>  
  3.   
  4. struct parent  
  5. {  
  6.     static char* expression;  
  7.     static int index;  
  8.     static int end_state;  
  9.     static int doom_state;  
  10.   
  11.     static void reset(char* expr);  
  12.     virtual parent* transition() {}  
  13. };  
  14.   
  15. void parent::reset(char* expr)  
  16. {  
  17.     expression = new char[strlen(expr) + 1];  
  18.     strcpy(expression,expr);  
  19.     end_state = 0;  
  20.     doom_state = 0;  
  21.     index = 0;  
  22. }  
  23.   
  24. struct state1:public parent  
  25. {  
  26.     parent* transition();  
  27. };  
  28.   
  29. struct state2:public parent  
  30. {  
  31.     parent* transition();  
  32. };  
  33.   
  34. struct state3:public parent  
  35. {  
  36.     parent* transition();  
  37. };  
  38.   
  39. struct state4:public parent  
  40. {  
  41.     parent* transition();  
  42. };  
  43.   
  44. struct state5:public parent  
  45. {  
  46.     parent* transition();  
  47. };  
  48.   
  49. char* parent::expression = NULL;  
  50. int parent::doom_state = 0;  
  51. int parent::end_state = 0;  
  52. int parent::index = 0;  
  53.   
  54. state1 s1;  
  55. state2 s2;  
  56. state3 s3;  
  57. state4 s4;  
  58. state5 s5;  
  59.   
  60. parent* state1::transition()  
  61. {  
  62.     switch(expression[index++])  
  63.     {  
  64.         case 'A':  
  65.             return &s2;  
  66.         case 'B':  
  67.             return &s3;  
  68.         case 'C':  
  69.             return &s4;  
  70.         case 'D':  
  71.             return &s5;  
  72.         case '/0':  
  73.             doom_state = 1;  
  74.         default:  
  75.             doom_state = 1;  
  76.     }  
  77. }  
  78.   
  79. parent* state2::transition()  
  80. {  
  81.     switch(expression[index++])  
  82.     {  
  83.         case 'E':  
  84.             return &s2;  
  85.         case 'I':  
  86.             end_state = 1;  
  87.             break;  
  88.         case '/0':  
  89.             doom_state = 1;  
  90.         default:  
  91.             doom_state = 1;  
  92.     }  
  93. }  
  94.   
  95. parent* state3::transition()  
  96. {  
  97.     switch(expression[index++])  
  98.     {  
  99.         case 'F':  
  100.             return &s3;  
  101.         case 'M':  
  102.             return &s4;  
  103.         case 'J':  
  104.             end_state = 1;  
  105.             break;  
  106.         case '/0':  
  107.             doom_state = 1;  
  108.         default:  
  109.             doom_state = 1;  
  110.     }  
  111. }  
  112.   
  113. parent* state4::transition()  
  114. {  
  115.     switch(expression[index++])  
  116.     {  
  117.         case 'G':  
  118.             return &s4;  
  119.         case 'K':  
  120.             end_state = 1;  
  121.             break;  
  122.         case '/0':  
  123.             doom_state = 1;  
  124.         default:  
  125.             doom_state = 1;  
  126.     }  
  127. }  
  128.   
  129. parent* state5::transition()  
  130. {  
  131.     switch(expression[index++])  
  132.     {  
  133.         case 'O':  
  134.             return &s2;  
  135.         case 'H':  
  136.             return &s5;  
  137.         case 'L':  
  138.             end_state = 1;  
  139.             break;  
  140.         case 'N':  
  141.             return &s4;  
  142.         case '/0':  
  143.             doom_state = 1;  
  144.         default:  
  145.             doom_state = 1;  
  146.     }  
  147. }  
  148.   
  149. int main()  
  150. {  
  151.     char input_string[80];  
  152.     printf("Enter input expression: ");  
  153.     scanf("%s",input_string);  
  154.     parent::reset(input_string);  
  155.     parent *ptr;  
  156.     ptr = s1.transition();  
  157.     while(ptr->end_state !=1 && ptr->doom_state != 1)  
  158.     {  
  159.         ptr = ptr->transition();  
  160.     }  
  161.     if(ptr->end_state == 1)  
  162.         printf("/nValid input expression");  
  163.     else  
  164.         printf("/nInvalid input expression");  
  165.   
  166.     return 0;  
  167. }  

 

程序分析和改进：

  • main()的变量Ptr中记录了FSM的当前状态，而FSM管理着输入的字符串，这些都是对方的职责。由此造成了main和parent之间的高度耦合。我们应做到让二者各司其责：把字符串管理分离出来放到main中，当前状态放到parent中。原则：降低耦合性--将类之间的交互最小化。
  • 在parent中引入静态数据成员current指向当前状态：当FSM处于消亡状态时，current=null；当FSM处于结束状态时，current=&s6。这样可以去掉原来的数据成员end_state和doom_state。用end_state()和doom_state()来测试current。

程序3 对parent和main进行解耦

 

 

 

[cpp] view
plaincopy

  1. #include <string.h>  
  2. #include <stdio.h>  
  3.   
  4. class parent  
  5. {  
  6.     private:  
  7.         static parent *current;  
  8.     protected:  
  9.         virtual parent* transition(char) { return NULL;}  
  10.     public:  
  11.         static void reset();  
  12.         static void advance(char);  
  13.         static int end_state();  
  14.         static int doom_state();  
  15.   
  16. };  
  17.   
  18. struct state1:public parent  
  19. {  
  20.     parent* transition(char);  
  21. };  
  22.   
  23. struct state2:public parent  
  24. {  
  25.     parent* transition(char);  
  26. };  
  27.   
  28. struct state3:public parent  
  29. {  
  30.     parent* transition(char);  
  31. };  
  32.   
  33. struct state4:public parent  
  34. {  
  35.     parent* transition(char);  
  36. };  
  37.   
  38. struct state5:public parent  
  39. {  
  40.     parent* transition(char);  
  41. };  
  42. struct state6:public parent  
  43. {  
  44.     parent* transition(char);  
  45. };  
  46.   
  47. parent* parent::current = NULL;  
  48. state1 s1;  
  49. state2 s2;  
  50. state3 s3;  
  51. state4 s4;  
  52. state5 s5;  
  53. state6 s6;  
  54.   
  55. void parent::reset()  
  56. {  
  57.     current = &s1;  
  58. }  
  59. void parent::advance(char x)  
  60. {  
  61.     if(current)  
  62.         current = current->transition(x);  
  63. }  
  64.   
  65. int parent::end_state()  
  66. {  
  67.     return current == &s6;  
  68. }  
  69.   
  70. int parent::doom_state()  
  71. {  
  72.     return current == NULL;  
  73. }  
  74. parent* state1::transition(char x)  
  75. {  
  76.     switch(x)  
  77.     {  
  78.         case 'A':  
  79.             return &s2;  
  80.         case 'B':  
  81.             return &s3;  
  82.         case 'C':  
  83.             return &s4;  
  84.         case 'D':  
  85.             return &s5;  
  86.         default:  
  87.             return NULL;  
  88.     }  
  89. }  
  90.   
  91. parent* state2::transition(char x)  
  92. {  
  93.     switch(x)  
  94.     {  
  95.         case 'E':  
  96.             return &s2;  
  97.         case 'I':  
  98.             return &s6;  
  99.         default:  
  100.             return NULL;  
  101.     }  
  102. }  
  103.   
  104. parent* state3::transition(char x)  
  105. {  
  106.     switch(x)  
  107.     {  
  108.         case 'F':  
  109.             return &s3;  
  110.         case 'M':  
  111.             return &s4;  
  112.         case 'J':  
  113.             return &s6;  
  114.         default:  
  115.             return NULL;  
  116.     }  
  117. }  
  118.   
  119. parent* state4::transition(char x)  
  120. {  
  121.     switch(x)  
  122.     {  
  123.         case 'G':  
  124.             return &s4;  
  125.         case 'K':  
  126.             return &s6;  
  127.         default:  
  128.             return NULL;  
  129.     }  
  130. }  
  131.   
  132. parent* state5::transition(char x)  
  133. {  
  134.     switch(x)  
  135.     {  
  136.         case 'O':  
  137.             return &s2;  
  138.         case 'H':  
  139.             return &s5;  
  140.         case 'L':  
  141.             return &s6;  
  142.         case 'N':  
  143.             return &s4;  
  144.         default:  
  145.             return NULL;  
  146.     }  
  147. }  
  148.   
  149. parent* state6::transition(char)  
  150. {  
  151.     return NULL;  
  152. }  
  153.   
  154. int main()  
  155. {  
  156.     char input_string[80];  
  157.     printf("Enter input expression: ");  
  158.     scanf("%s",input_string);  
  159.     parent::reset();  
  160.     int index = 0;  
  161.     parent::advance(input_string[index++]);  
  162.     while(!parent::end_state() && !parent::doom_state())  
  163.     {  
  164.         parent::advance(input_string[index++]);  
  165.     }  
  166.     if(parent::end_state())  
  167.         printf("/nValid input expression");  
  168.     else  
  169.         printf("/nInvalid input expression");  
  170.   
  171.     return 0;  
  172. }  

 

 

    程序的进一步分析和改进：考虑parent和statej结构之间的继承关系：parent是含有FSM状态statej的模块，它们之间不存在"is A"的关系，更确切的说，状态集合更应该是FSM的一部分，二者是一种"has A"关系。程序中parent试图去既表示某个状态，又表示FSM(一种规则），由于parent要实现两种功能，因此程序没有很好的内聚性。解决的办法是提取出两种抽象，并将parent拆分为两个不同的类：state和fsm，即状态和规则。state仅用于表示状态的抽象基类，而fsm仅用于表示FSM模型。

原则：每个类应该只有唯一的、类聚的功能。

 

                                             程序4 parent被拆分为state和fsm

 

[cpp] view
plaincopy

  1. #include <string.h>  
  2. #include <stdio.h>  
  3.   
  4. struct state  
  5. {  
  6.     virtual state* transition(char) = 0;  
  7. };  
  8. class fsm  
  9. {  
  10.     private:  
  11.         static state *current;  
  12.     public:  
  13.         static void reset();  
  14.         static void advance(char);  
  15.         static int end_state();  
  16.         static int doom_state();  
  17.   
  18. };  
  19.   
  20. struct state1:public state  
  21. {  
  22.     state* transition(char);  
  23. };  
  24.   
  25. struct state2:public state  
  26. {  
  27.     state* transition(char);  
  28. };  
  29.   
  30. struct state3:public state  
  31. {  
  32.     state* transition(char);  
  33. };  
  34.   
  35. struct state4:public state  
  36. {  
  37.     state* transition(char);  
  38. };  
  39.   
  40. struct state5:public state  
  41. {  
  42.     state* transition(char);  
  43. };  
  44. struct state6:public state  
  45. {  
  46.     state* transition(char);  
  47. };  
  48.   
  49. state* fsm::current = NULL;  
  50. state1 s1;  
  51. state2 s2;  
  52. state3 s3;  
  53. state4 s4;  
  54. state5 s5;  
  55. state6 s6;  
  56.   
  57. void fsm::reset()  
  58. {  
  59.     current = &s1;  
  60. }  
  61. void fsm::advance(char x)  
  62. {  
  63.     if(current)  
  64.         current = current->transition(x);  
  65. }  
  66.   
  67. int fsm::end_state()  
  68. {  
  69.     return current == &s6;  
  70. }  
  71.   
  72. int fsm::doom_state()  
  73. {  
  74.     return current == NULL;  
  75. }  
  76. state* state1::transition(char x)  
  77. {  
  78.     switch(x)  
  79.     {  
  80.         case 'A':  
  81.             return &s2;  
  82.         case 'B':  
  83.             return &s3;  
  84.         case 'C':  
  85.             return &s4;  
  86.         case 'D':  
  87.             return &s5;  
  88.         default:  
  89.             return NULL;  
  90.     }  
  91. }  
  92.   
  93. state* state2::transition(char x)  
  94. {  
  95.     switch(x)  
  96.     {  
  97.         case 'E':  
  98.             return &s2;  
  99.         case 'I':  
  100.             return &s6;  
  101.         default:  
  102.             return NULL;  
  103.     }  
  104. }  
  105.   
  106. state* state3::transition(char x)  
  107. {  
  108.     switch(x)  
  109.     {  
  110.         case 'F':  
  111.             return &s3;  
  112.         case 'M':  
  113.             return &s4;  
  114.         case 'J':  
  115.             return &s6;  
  116.         default:  
  117.             return NULL;  
  118.     }  
  119. }  
  120.   
  121. state* state4::transition(char x)  
  122. {  
  123.     switch(x)  
  124.     {  
  125.         case 'G':  
  126.             return &s4;  
  127.         case 'K':  
  128.             return &s6;  
  129.         default:  
  130.             return NULL;  
  131.     }  
  132. }  
  133.   
  134. state* state5::transition(char x)  
  135. {  
  136.     switch(x)  
  137.     {  
  138.         case 'O':  
  139.             return &s2;  
  140.         case 'H':  
  141.             return &s5;  
  142.         case 'L':  
  143.             return &s6;  
  144.         case 'N':  
  145.             return &s4;  
  146.         default:  
  147.             return NULL;  
  148.     }  
  149. }  
  150.   
  151. state* state6::transition(char)  
  152. {  
  153.     return NULL;  
  154. }  
  155.   
  156. int main()  
  157. {  
  158.     char input_string[80];  
  159.     printf("Enter input expression: ");  
  160.     scanf("%s",input_string);  
  161.     fsm::reset();  
  162.     int index = 0;  
  163.     fsm::advance(input_string[index++]);  
  164.     while(!fsm::end_state() && !fsm::doom_state())  
  165.     {  
  166.         fsm::advance(input_string[index++]);  
  167.     }  
  168.     if(fsm::end_state())  
  169.         printf("/nValid input expression");  
  170.     else  
  171.         printf("/nInvalid input expression");  

 

 

 

     写到这里，你也许觉得完美了，其实不然：fsm仍然是一个模块类，它包含的是一组通过静态函数来操作的静态变量。如果我们可以很容易的创建一个抽象数据类型(ADT)，那么我们就不应该将类设计为模块形式。并且使用了ADT后，我们可以在需要的时候才进行实例化。

原则：我们应该将类设计成抽象数据类型而不是模块类。

 

                                             程序5 将fsm从模块内转化为ADT

 

[cpp] view
plaincopy

  1. #include <string.h>  
  2. #include <stdio.h>  
  3.   
  4. struct state  
  5. {  
  6.     virtual state* transition(char) = 0;  
  7. };  
  8.   
  9. class fsm  
  10. {  
  11.     private:  
  12.         state *current;  
  13.     public:  
  14.         void reset();  
  15.         void a dvance(char);  
  16.         int end_state();  
  17.         int doom_state();  
  18.         fsm();  
  19.   
  20. };  
  21. struct state1:public state  
  22. {  
  23.     state* transition(char);  
  24. };  
  25.   
  26. struct state2:public state  
  27. {  
  28.     state* transition(char);  
  29. };  
  30.   
  31. struct state3:public state  
  32. {  
  33.     state* transition(char);  
  34. };  
  35.   
  36. struct state4:public state  
  37. {  
  38.     state* transition(char);  
  39. };  
  40.   
  41. struct state5:public state  
  42. {  
  43.     state* transition(char);  
  44. };  
  45. struct state6:public state  
  46. {  
  47.     state* transition(char);  
  48. };  
  49.   
  50.   
  51. state1 s1;  
  52. state2 s2;  
  53. state3 s3;  
  54. state4 s4;  
  55. state5 s5;  
  56. state6 s6;  
  57.   
  58. fsm::fsm()  
  59. {  
  60.     current = NULL;  
  61. }  
  62.   
  63. void fsm::reset()  
  64. {  
  65.     current = &s1;  
  66. }  
  67. void fsm::advance(char x)  
  68. {  
  69.     if(current)  
  70.         current = current->transition(x);  
  71. }  
  72.   
  73. int fsm::end_state()  
  74. {  
  75.     return current == &s6;  
  76. }  
  77.   
  78. int fsm::doom_state()  
  79. {  
  80.     return current == NULL;  
  81. }  
  82. state* state1::transition(char x)  
  83. {  
  84.     switch(x)  
  85.     {  
  86.         case 'A':  
  87.             return &s2;  
  88.         case 'B':  
  89.             return &s3;  
  90.         case 'C':  
  91.             return &s4;  
  92.         case 'D':  
  93.             return &s5;  
  94.         default:  
  95.             return NULL;  
  96.     }  
  97. }  
  98.   
  99. state* state2::transition(char x)  
  100. {  
  101.     switch(x)  
  102.     {  
  103.         case 'E':  
  104.             return &s2;  
  105.         case 'I':  
  106.             return &s6;  
  107.         default:  
  108.             return NULL;  
  109.     }  
  110. }  
  111.   
  112. state* state3::transition(char x)  
  113. {  
  114.     switch(x)  
  115.     {  
  116.         case 'F':  
  117.             return &s3;  
  118.         case 'M':  
  119.             return &s4;  
  120.         case 'J':  
  121.             return &s6;  
  122.         default:  
  123.             return NULL;  
  124.     }  
  125. }  
  126.   
  127. state* state4::transition(char x)  
  128. {  
  129.     switch(x)  
  130.     {  
  131.         case 'G':  
  132.             return &s4;  
  133.         case 'K':  
  134.             return &s6;  
  135.         default:  
  136.             return NULL;  
  137.     }  
  138. }  
  139.   
  140. state* state5::transition(char x)  
  141. {  
  142.     switch(x)  
  143.     {  
  144.         case 'O':  
  145.             return &s2;  
  146.         case 'H':  
  147.             return &s5;  
  148.         case 'L':  
  149.             return &s6;  
  150.         case 'N':  
  151.             return &s4;  
  152.         default:  
  153.             return NULL;  
  154.     }  
  155. }  
  156.   
  157. state* state6::transition(char)  
  158. {  
  159.     return NULL;  
  160. }  
  161.   
  162. int main()  
  163. {  
  164.     char input_string[80];  
  165.     printf("Enter input expression: ");  
  166.     scanf("%s",input_string);  
  167.     fsm m;  
  168.     m.reset();  
  169.     int index = 0;  
  170.     m.advance(input_string[index++]);  
  171.     while(!m.end_state() && !m.doom_state())  
  172.     {  
  173.         m.advance(input_string[index++]);  
  174.     }  
  175.     if(m.end_state())  
  176.         printf("/nValid input expression");  
  177.     else  
  178.         printf("/nInvalid input expression");  
  179.   
  180.     return 0;  
  181. }  

 

现在，程序的设计思路就变得非常清晰了：

  1. 状态转换图描述了FSM。
  2. 状态转换图中的每个节点都对应一个状态对象。
  3. 每个状态对象都通过一个输入字符转换到另一个状态上。

     接着，考虑下状态：状态的确切含义是在每一个状态中都提供了一种从输入字符到后继状态的映射，除了映射的值不同外，所有的状态在每次执行映射时的操作都是相似的。在计算机程序中，有两种基本的方法表示映射：一张表或者一个算法,用c++的术语说就是被动数据或者可执行代码。在本程序中，我们选用了可执行代码的方法来表示映射，但这与用被动数据的方法相比，这个程序显得更为复杂，并且通用性也不好。

 

                                           程序6 用数据表来表示转换映射

 

 

[cpp] view
plaincopy

  1. #include <string.h>  
  2. #include <limits.h>  
  3. #include <stdio.h>  
  4.   
  5. const int range = CHAR_MAX + 1;//0...CHAR_MAX  
  6.   
  7. struct state  
  8. {  
  9.     state* transition[range];  
  10.     state();  
  11. };  
  12.   
  13. class fsm  
  14. {  
  15. private:  
  16.     state graph[6];  
  17.     state* current;  
  18. public:  
  19.     void reset();  
  20.     void advance(char);  
  21.     int end_state();  
  22.     int doom_state();  
  23.     fsm();  
  24. };  
  25.   
  26. state::state()  
  27. {  
  28.     for(int i = 0;i < range;++i)  
  29.         transition[i] = NULL;  
  30. }  
  31.   
  32. struct triple  
  33. {  
  34.     int from;  
  35.     char input;  
  36.     int to;  
  37. };  
  38.   
  39. fsm::fsm()  
  40. {  
  41.     static triple edges[] ={  
  42.         {1,'A',2},{1,'B',3},{1,'C',4},{1,'D',5},  
  43.         {2,'E',2},{2,'I',0},  
  44.         {3,'F',3},{3,'J',0},{3,'M',4},  
  45.         {4,'G',4},{4,'K',0},  
  46.         {5,'H',5},{5,'L',0},{5,'O',2},{5,'N',4},  
  47.         {0,0,0}  
  48.     };  
  49.   
  50.     for(triple* e = edges;e->from != 0;++e)  
  51.         graph[e->from].transition[e->input] = &graph[e->to];  
  52.     current = NULL;  
  53. }  
  54.   
  55. void fsm::reset()  
  56. {  
  57.     current = &graph[1];  
  58. }  
  59.   
  60. void fsm::advance(char x)  
  61. {  
  62.     if(current)  
  63.         current = current->transition[x];  
  64. }  
  65.   
  66. int fsm::end_state()  
  67. {  
  68.     return current == &graph[0];  
  69. }  
  70.   
  71. int fsm::doom_state()  
  72. {  
  73.     return current == NULL;  
  74. }  
  75.   
  76. int main()  
  77. {  
  78.     char input_string[80];  
  79.     printf("Enter input expression:");  
  80.     scanf("%s",input_string);  
  81.     fsm m;  
  82.     m.reset();  
  83.     int index = 0;  
  84.     m.advance(input_string[index++]);  
  85.     while (!m.end_state() && !m.doom_state())  
  86.     {  
  87.         m.advance(input_string[index++]);  
  88.     }  
  89.     if(m.end_state())  
  90.         printf("Valid input expression!/n");  
  91.     else  
  92.         printf("Invalid input expression!/n");  
  93.   
  94.     return 0;  
  95. }  

 

 

     在上面的程序中还存在较大缺陷：当我们创建多个fsm对象时，每个fsm对象都是同一个FSM的副本，即规则都一样。我们只需将fsm再抽象化，就可以对这个类进行泛化，以处理任意的状态转换图，这种做法是很有实际意义的。

原则：如果抽象化某个类比较简单时，我们最好不要只实现某种具体的情形。

                                           程序7 从fsm中派生出sample

[cpp] view
plaincopy

  1. #include <string.h>  
  2. #include <limits.h>  
  3. #include <stdio.h>  
  4.   
  5. const int range = CHAR_MAX + 1;//0..CHAR_MAX  
  6.   
  7. struct state  
  8. {  
  9.     state* transition[range];  
  10.     state();  
  11. };  
  12.   
  13. struct triple  
  14. {  
  15.     int from;  
  16.     char input;  
  17.     int to;  
  18. };  
  19.   
  20. class fsm  
  21. {  
  22. private:  
  23.     state* graph;  
  24.     state* current;  
  25. public:  
  26.     void reset();  
  27.     void advance(char);  
  28.     int end_state();  
  29.     int doom_state();  
  30.     fsm(triple*);  
  31.     virtual ~fsm();//公有基类的析构函数应该被声明为虚函数  
  32. };  
  33.   
  34. state::state()  
  35. {  
  36.     for(int i = 0;i < range;++i)  
  37.         transition[i] = NULL;  
  38. }  
  39.   
  40. fsm::fsm(triple* p)  
  41. {  
  42.     int max_node = 0;  
  43.     for(triple* e = p;e->from;++e)  
  44.     {  
  45.         if(e->from > max_node)  
  46.             max_node = e->from;  
  47.         if(e->to > max_node)  
  48.             max_node = e->to;  
  49.     }  
  50.     graph = new state[max_node + 1];  
  51.     for(e = p;e->from ;++e)  
  52.         graph[e->from].transition[e->input] = &graph[e->to];  
  53.     current = NULL;  
  54. }  
  55. fsm::~fsm()  
  56. {  
  57.     delete [] graph;  
  58. }  
  59. void fsm::reset()  
  60. {  
  61.     current = &graph[1];  
  62. }  
  63.   
  64. void fsm::advance(char x)  
  65. {  
  66.     if(current)  
  67.         current = current->transition[x];  
  68. }  
  69.   
  70. int fsm::end_state()  
  71. {  
  72.     return current == &graph[0];  
  73. }  
  74.   
  75. int fsm::doom_state()  
  76. {  
  77.     return current == NULL;  
  78. }  
  79. class sample:public fsm  
  80. {  
  81.     static triple edges[];  
  82. public:  
  83.     sample();  
  84. };  
  85.   
  86. triple sample::edges[] ={  
  87.         {1,'A',2},{1,'B',3},{1,'C',4},{1,'D',5},  
  88.         {2,'E',2},{2,'I',0},  
  89.         {3,'F',3},{3,'J',0},{3,'M',4},  
  90.         {4,'G',4},{4,'K',0},  
  91.         {5,'H',5},{5,'L',0},{5,'O',2},{5,'N',4},  
  92.         {0,0,0}  
  93.     };  
  94. sample::sample():fsm(edges)  
  95. {  
  96. }  
  97. int main()  
  98. {  
  99.     char input_string[80];  
  100.     printf("Enter input expression:");  
  101.     scanf("%s",input_string);  
  102.     sample m;  
  103.     m.reset();  
  104.     int index = 0;  
  105.     m.advance(input_string[index++]);  
  106.     while (!m.end_state() && !m.doom_state())  
  107.     {  
  108.         m.advance(input_string[index++]);  
  109.     }  
  110.     if(m.end_state())  
  111.         printf("Valid input expression!/n");  
  112.     else  
  113.         printf("Invalid input expression!/n");  
  114.   
  115.     return 0;  
  116. }  

 

 

备注：

  1. 有限状态机也叫做有限自动控制机，在许多关于编译器、形式语言、离散数学的书中都有正式的描述。
  2. 参考文献：《c++编程风格》（c++ programming style ）作者 Tom Cargill 译者 聂雪军 机械工业出版社2007.1

 

返回
【上篇】
【下篇】

作者:

抱歉!评论已关闭.

返回首页

Copyright © 2013-2018 学步园  保留所有权利.
软文销售 QQ客服：2265327166 点击这里给我发消息（其他合作也可洽谈）
必威体育
必威电竞