有限状态机FSM详解及其实现

有限状态机,也称为 FSM(Finite State Machine) ,其在任意时刻都处于有限状态集合中的某一状态。当其获得一个输入字符 时,将从 当前状态 转换到 另一个状态 ,或者仍然保持在当前状态 。任何一个FSM都可以用状态转换图来描述,图中的节点表示FSM中的一个状态,有向加权边表示输入字符时状态的变化。如果图中不存在与当前状态与输入字符对应的有向边,则FSM将进入“消亡状态 (Doom State) ”,此后FSM将一直保持“消亡状态”。状态转换图中还有两个特殊状态:状态1称为 “起始状态” ,表示FSM的初始状态。状态6称为 “结束状态” ,表示成功识别了所输入的字符序列。

在启动一个FSM时,首先必须将FSM置于“起始状态”,然后输入一系列字符,最终,FSM会到达“结束状态”或者“消亡状态”。


说明:

在通常的FSM模型中,一般还存在一个“接受状态”,并且FSM可以从“接受状态”转换到另一个状态,只有在识别最后一个字符后,才会根据最终状态来决定是否接受所输入的字符串。此外,也可以将“其实状态”也作为接受状态,因此空的输入序列也是可以接受的。

FSM的实现

程序设计思路大致如下:

  • 使用状态转换图描述FSM
  • 状态转换图中的结点对应不同的状态对象
  • 每个状态对象通过一个输入字符转换到另一个状态上,或者保持原状态不变。

通过输入字符从一个状态切换到另一个状态的过程,我们称之为一个 映射 。在计算机程序设计中, 我们可以有两种表示映射的方法:

  • 通过算法表示,即“可执行代码(Executable Code)”方式
  • 通过一张映射表,即“被动数据(Passive Data)”方式

如下详细介绍这两种实现方式:

  • 通过Executable Code 实现映射的FSM :

这种方式主要是通过条件分支来处理不同的字符,如if或者switch语句块,如

  1. State* State1::Transition(char c)  
  2. {  
  3.     switch(c)  
  4.     {  
  5.     case 'A':  
  6.         return &s2;  
  7.     case 'B':  
  8.         return &s3;  
  9.     case 'C':  
  10.         return &s4;  
  11.     case 'D':  
  12.         return &s5;  
  13.     case '\0':  
  14.         return NULL;  
  15.     default:  
  16.         return NULL;  
  17.     }  
  18. }  


  1. // fsm_with_executable_code.h  
  2. #ifndef FSM_WITH_EXECUTABLE_CODE_H  
  3. #define FSM_WITH_EXECUTABLE_CODE_H  
  4.   
  5. #include <string.h>  
  6.   
  7. class State  
  8. {  
  9. public:  
  10.     virtual State* Transition(char c) = 0;  
  11. };  
  12.   
  13. class Fsm  
  14. {  
  15. public:  
  16.     Fsm();  
  17.     void Reset();            // move to start state  
  18.     void Advance(char c);    // advance one transition  
  19.     int EndState();  
  20.     int DoomState();  
  21.   
  22. private:  
  23.     State* p_current;   // &s1, &s2, ..., &s6; NULL ==> doom  
  24. };  
  25.   
  26.   
  27. class State1 : public State  
  28. {  
  29. public:  
  30.     State* Transition(char c);  
  31. };  
  32.   
  33. class State2 : public State  
  34. {  
  35. public:  
  36.     State* Transition(char c);  
  37. };  
  38.   
  39. class State3 : public State  
  40. {  
  41. public:  
  42.     State* Transition(char c);  
  43. };  
  44.   
  45. class State4 : public State  
  46. {  
  47. public:  
  48.     State* Transition(char c);  
  49. };  
  50.   
  51. class State5 : public State  
  52. {  
  53. public:  
  54.     State* Transition(char c);  
  55. };  
  56.   
  57. class State6 : public State  
  58. {  
  59. public:  
  60.     State* Transition(char c);  
  61. };  
  62.   
  63. #endif // FSM_WITH_EXECUTABLE_CODE_H  
  64.   
  65. // fsm_with_executable_code.cc  
  66. #include "fsm_with_executable_code.h"  
  67.   
  68. State1 s1;  
  69. State2 s2;  
  70. State3 s3;  
  71. State4 s4;  
  72. State5 s5;  
  73. State6 s6;  
  74.   
  75. Fsm::Fsm()  
  76. {  
  77.     p_current = NULL;  
  78. }  
  79.   
  80. void Fsm::Reset()  
  81. {  
  82.     p_current = &s1;  
  83. }  
  84.   
  85. void Fsm::Advance(char c)  
  86. {  
  87.     if (p_current != NULL)  
  88.         p_current = p_current->Transition(c);  
  89. }  
  90.   
  91. int Fsm::EndState()  
  92. {  
  93.     return p_current == &s6;  
  94. }  
  95.   
  96. int Fsm::DoomState()  
  97. {  
  98.     return p_current == NULL;  
  99. }  
  100. State* State1::Transition(char c)  
  101. {  
  102.     switch(c)  
  103.     {  
  104.     case 'A':  
  105.         return &s2;  
  106.     case 'B':  
  107.         return &s3;  
  108.     case 'C':  
  109.         return &s4;  
  110.     case 'D':  
  111.         return &s5;  
  112.     case '\0':  
  113.         return NULL;  
  114.     default:  
  115.         return NULL;  
  116.     }  
  117. }  
  118.   
  119. State* State2::Transition(char c)  
  120. {  
  121.     switch(c)  
  122.     {  
  123.     case 'E':  
  124.         return &s2;  
  125.     case 'I':  
  126.         return &s6;  
  127.     case '\0':  
  128.         return NULL;  
  129.     default:  
  130.         return NULL;  
  131.     }  
  132. }  
  133.   
  134. State* State3::Transition(char c)  
  135. {  
  136.     switch(c)  
  137.     {  
  138.     case 'F':  
  139.         return &s3;  
  140.     case 'M':  
  141.         return &s4;  
  142.     case 'J':  
  143.         return &s6;  
  144.     case '\0':  
  145.         return NULL;  
  146.     default:  
  147.         return NULL;  
  148.     }  
  149. }  
  150.   
  151. State* State4::Transition(char c)  
  152. {  
  153.     switch(c)  
  154.     {  
  155.     case 'G':  
  156.         return &s4;  
  157.     case 'K':  
  158.         return &s6;  
  159.     case '\0':  
  160.         return NULL;  
  161.     default:  
  162.         return NULL;  
  163.     }  
  164. }  
  165.   
  166. State* State5::Transition(char c)  
  167. {  
  168.     switch(c)  
  169.     {  
  170.     case 'O':  
  171.         return &s2;  
  172.     case 'H':  
  173.         return &s5;  
  174.     case 'L':  
  175.         return &s6;  
  176.     case 'N':  
  177.         return &s4;  
  178.     case '\0':  
  179.         return NULL;  
  180.     default:  
  181.         return NULL;  
  182.     }  
  183. }  
  184.   
  185. State* State6::Transition(char c)  
  186. {  
  187.     return NULL;  
  188. }  
  189.   
  190. // test_with_executable_code.cc  
  191. #include "fsm_with_executable_code.h"  
  192.   
  193. #include "stdio.h"  // printf, scanf  
  194. #include "stdlib.h" // system  
  195.   
  196. void test_fsm()  
  197. {  
  198.     char input_string[80];  
  199.     printf("Enter input expression: ");  
  200.     scanf("%s", input_string);  
  201.   
  202.     Fsm fsm;  
  203.     fsm.Reset();  
  204.     int index = 0;  
  205.     fsm.Advance(input_string[index++]);  
  206.   
  207.     while (!fsm.EndState() && !fsm.DoomState())  
  208.         fsm.Advance(input_string[index++]);  
  209.   
  210.     if (fsm.EndState())  
  211.         printf("\nValid input expression");  
  212.     else  
  213.         printf("\nInvalid input expression");  
  214. }  
  215.   
  216. int main()  
  217. {  
  218.     test_fsm();  
  219.   
  220.     system("pause");  
  221. }  

  •   通过Passive Data 实现映射的FSM :

在如上的switch分支中,其使用类型大致相同,因此,我们可以考虑将相似的信息保存到一张表中,这样就可以在程序中避免很多函数调用。在每个状态中都使用一张转换表来表示映射关系,转换表的索引使用输入字符来表示。此外,由于通过转换表就可以描述不同状态之间的变化,那么就没有必要将每种状态定义为一个类了,即不需要多余的继承和虚函数了,仅使用一个State即可。

  1. #include <limits.h>  
  2.   
  3. class State  
  4. {  
  5. public:  
  6.     State();  
  7.     State* transition[range];  
  8. };  
  9.   
  10. 对于任意一个状态state和输入字符c,后续状态都可以通过state.transition[c]来确定。  
  11.   
  12. 类Fsm中的成员state包含6个状态,为了对应方便,我们将结束状态放在state[0]中,每个状态都使用一个三元组 { 当前状态,输入字符,下一个状态 } 来表示:  
  13.   
  14. struct TransGraph   // use triple to describe map  
  15. {  
  16.     int current_state;  
  17.     char input_char;  
  18.     int next_state;  
  19. };  
如此,使用了转换表代替了虚函数,简化了程序的设计。
  1. // fsm_with_passive_data.h  
  2. #ifndef FSM_WITH_PASSIVE_DATA_H  
  3. #define FSM_WITH_PASSIVE_DATA_H  
  4.   
  5. #include <string.h>  
  6. #include <limits.h>     // CHAR_MAX  
  7.   
  8. const int range = CHAR_MAX + 1;  
  9.   
  10. class State  
  11. {  
  12. public:  
  13.     State();  
  14.     State* transition[range];  
  15. };  
  16.   
  17. struct TransGraph   // use triple to describe map  
  18. {  
  19.     int current_state;  
  20.     char input_char;  
  21.     int next_state;  
  22. };  
  23.   
  24. class Fsm  
  25. {  
  26. public:  
  27.     Fsm();  
  28.     void Reset();            // move to start state  
  29.     void Advance(char c);    // advance one transition  
  30.     int EndState();  
  31.     int DoomState();  
  32.   
  33. private:  
  34.     State* p_current;   // &s1, &s2, ..., &s6; NULL ==> doom  
  35.     State state[6];     // 6 states, state[0] is end state  
  36. };  
  37.   
  38.   
  39. #endif // FSM_WITH_PASSIVE_DATA_H  
  40.   
  41. // fsm_with_passive_data.cc  
  42. #include "fsm_with_passive_data.h"  
  43.   
  44. State::State()  
  45. {  
  46.     for (int i = 0; i < range; ++i)  
  47.         transition[i] = NULL;  
  48. }  
  49.   
  50. Fsm::Fsm()  
  51. {  
  52.     static TransGraph graph[] =  
  53.     {  
  54.         {1, 'A', 2}, {1, 'B', 3}, {1, 'C', 4}, {1, 'D', 5},  
  55.         {2, 'E', 2}, {2, 'I', 0},  
  56.         {3, 'F', 3}, {3, 'J', 0}, {3, 'M', 4},  
  57.         {4, 'G', 4}, {4, 'K', 0},  
  58.         {5, 'H', 5}, {5, 'L', 0}, {5, 'O', 2}, {5, 'N', 4},  
  59.         {0, 0, 0}  
  60.     };  
  61.   
  62.     for (TransGraph* p_tg = graph; p_tg->current_state != 0; ++p_tg)  
  63.         state[p_tg->current_state].transition[p_tg->input_char] = &state[p_tg->next_state];  
  64.   
  65.     p_current = NULL;  
  66. }  
  67.   
  68. void Fsm::Reset()  
  69. {  
  70.     p_current = &state[1];  
  71. }  
  72.   
  73. void Fsm::Advance(char c)  
  74. {  
  75.     if (p_current != NULL)  
  76.         p_current = p_current->transition[c];  
  77. }  
  78.   
  79. int Fsm::EndState()  
  80. {  
  81.     return p_current == &state[0];  
  82. }  
  83.   
  84. int Fsm::DoomState()  
  85. {  
  86.     return p_current == NULL;  
  87. }  
  88.   
  89. // test_with_passive_data.cc  
  90. #include "fsm_with_passive_data.h"  
  91.   
  92. #include "stdio.h"  // printf, scanf  
  93. #include "stdlib.h" // system  
  94.   
  95. void test_fsm()  
  96. {  
  97.     char input_string[80];  
  98.     printf("Enter input expression: ");  
  99.     scanf("%s", input_string);  
  100.   
  101.     Fsm fsm;  
  102.     fsm.Reset();  
  103.     int index = 0;  
  104.     fsm.Advance(input_string[index++]);  
  105.   
  106.     while (!fsm.EndState() && !fsm.DoomState())  
  107.         fsm.Advance(input_string[index++]);  
  108.   
  109.     if (fsm.EndState())  
  110.         printf("\nValid input expression");  
  111.     else  
  112.         printf("\nInvalid input expression");  
  113. }  
  114.   
  115.   
  116. int main()  
  117. {  
  118.     test_fsm();  
  119.   
  120.     system("pause");  
  121. }  

通用FSM的设计

如果类Fsm可以表示任意类型的FSM,那么就更符合程序设计的要求了。在构造函数中执行的具体配置应该被泛化为一种机制,我们通过这种机制来建立任意的FSM。在Fsm的构造函数中,应该将转换表作为一个参数传入,而非包含具体的转换表,如此,则不需要将转换表的大小硬编码到Fsm中了。因此,在构造函数中必须动态地创建这个存放转换表的内存空间,在析构函数中记着销毁这块内存。

  1. class Fsm  
  2. {  
  3. public:  
  4.     Fsm(TransGraph* p_tg);  
  5.     virtual ~Fsm();  
  6.     void Reset();  
  7.     void Advance(char c);  
  8.     int EndState();  
  9.     int DoomState();  
  10.   
  11. private:  
  12.     State* p_current;  
  13.     State* p_state;  
  14. };  
  15.   
  16. Fsm::Fsm(TransGraph* p_tg)  
  17. {  
  18.     int max_state = 0;  // size for dynamically allocated graph  
  19.     for (TransGraph* p_temp = p_tg; p_temp->current_state != 0; ++p_temp)  
  20.     {  
  21.         if (p_temp->current_state > max_state)  
  22.             max_state = p_temp->current_state;  
  23.         if (p_temp->next_state > max_state)  
  24.             max_state = p_temp->next_state;  
  25.     }  
  26.   
  27.     p_state = new State[max_state + 1];  
  28.     for (TransGraph* p_temp = p_tg; p_temp->current_state != 0; ++p_temp)  
  29.         p_state[p_temp->current_state].transition[p_temp->input_char] = &p_state[p_temp->next_state];  
  30.   
  31.     p_current = NULL;  
  32. }  
  33.   
  34. Fsm::~Fsm()  
  35. {  
  36.     delete []p_state;  
  37. }  

  1. // fsm_with_generalization.h  
  2. #ifndef FSM_WITH_GENERALIZATION_H  
  3. #define FSM_WITH_GENERALIZATION_H  
  4.   
  5. #include <string.h>  
  6. #include <limits.h>     // CHAR_MAX  
  7.   
  8. const int range = CHAR_MAX + 1;  
  9.   
  10. class State  
  11. {  
  12. public:  
  13.     State();  
  14.     State* transition[range];  
  15. };  
  16.   
  17. struct TransGraph  
  18. {  
  19.     int current_state;  
  20.     char input_char;  
  21.     int next_state;  
  22. };  
  23.   
  24. class Fsm  
  25. {  
  26. public:  
  27.     Fsm(TransGraph* p_tg);  
  28.     virtual ~Fsm();  
  29.     void Reset();  
  30.     void Advance(char c);  
  31.     int EndState();  
  32.     int DoomState();  
  33.   
  34. private:  
  35.     State* p_current;  
  36.     State* p_state;  
  37. };  
  38.   
  39.   
  40. #endif // FSM_WITH_GENERALIZATION_H  
  41.   
  42. // fsm_with_generalization.cc  
  43. #include "fsm_with_generalization.h"  
  44.   
  45. State::State()  
  46. {  
  47.     for (int i = 0; i < range; ++i)  
  48.         transition[i] = NULL;  
  49. }  
  50.   
  51. Fsm::Fsm(TransGraph* p_tg)  
  52. {  
  53.     int max_state = 0;  // size for dynamically allocated graph  
  54.     for (TransGraph* p_temp = p_tg; p_temp->current_state != 0; ++p_temp)  
  55.     {  
  56.         if (p_temp->current_state > max_state)  
  57.             max_state = p_temp->current_state;  
  58.         if (p_temp->next_state > max_state)  
  59.             max_state = p_temp->next_state;  
  60.     }  
  61.   
  62.     p_state = new State[max_state + 1];  
  63.     for (TransGraph* p_temp = p_tg; p_temp->current_state != 0; ++p_temp)  
  64.         p_state[p_temp->current_state].transition[p_temp->input_char] = &p_state[p_temp->next_state];  
  65.   
  66.     p_current = NULL;  
  67. }  
  68.   
  69. Fsm::~Fsm()  
  70. {  
  71.     delete []p_state;  
  72. }  
  73.   
  74. void Fsm::Reset()  
  75. {  
  76.     p_current = &p_state[1];  
  77. }  
  78.   
  79. void Fsm::Advance(char c)  
  80. {  
  81.     if (p_current != NULL)  
  82.         p_current = p_current->transition[c];  
  83. }  
  84.   
  85. int Fsm::EndState()  
  86. {  
  87.     return p_current == &p_state[0];  
  88. }  
  89.   
  90. int Fsm::DoomState()  
  91. {  
  92.     return p_current == NULL;  
  93. }  
  94.   
  95. // test_with_generalization.cc  
  96. #include "fsm_with_generalization.h"  
  97.   
  98. #include "stdio.h"  // printf, scanf  
  99. #include "stdlib.h" // system  
  100.   
  101. void test_fsm()  
  102. {  
  103.     char input_string[80];  
  104.     printf("Enter input expression: ");  
  105.     scanf("%s", input_string);  
  106.   
  107.     TransGraph graph[] =  
  108.     {  
  109.         {1, 'A', 2}, {1, 'B', 3}, {1, 'C', 4}, {1, 'D', 5},  
  110.         {2, 'E', 2}, {2, 'I', 0},  
  111.         {3, 'F', 3}, {3, 'J', 0}, {3, 'M', 4},  
  112.         {4, 'G', 4}, {4, 'K', 0},  
  113.         {5, 'H', 5}, {5, 'L', 0}, {5, 'O', 2}, {5, 'N', 4},  
  114.         {0, 0, 0}  
  115.     };  
  116.   
  117.     Fsm fsm(graph);  
  118.     fsm.Reset();  
  119.     int index = 0;  
  120.     fsm.Advance(input_string[index++]);  
  121.   
  122.     while (!fsm.EndState() && !fsm.DoomState())  
  123.         fsm.Advance(input_string[index++]);  
  124.   
  125.     if (fsm.EndState())  
  126.         printf("\nValid input expression");  
  127.     else  
  128.         printf("\nInvalid input expression");  
  129. }  
  130.   
  131.   
  132. int main()  
  133. {  
  134.     test_fsm();  
  135.   
  136.     system("pause");  
  137. }  

当然也可以将上述程序中的转换表不放在主程序中,而是由一个派生自Fsm的子类SpecificFsm提供,在SpecificFsm中设置具体的转换表,然后通过SpecificFsm的初始化列表传到基类Fsm中,这样在主程序中就可以使用SpecificFsm来进行操作了。


原文:http://www.cnblogs.com/benxintuzi/p/4931258.html

阅读更多
想对作者说点什么?

博主推荐

换一批

没有更多推荐了,返回首页