有限状态机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语句块，如

[cpp]  view plain  copy

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

[cpp]  view plain  copy

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即可。

[cpp]  view plain  copy

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

如此，使用了转换表代替了虚函数，简化了程序的设计。

[cpp]  view plain  copy

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中了。因此，在构造函数中必须动态地创建这个存放转换表的内存空间，在析构函数中记着销毁这块内存。

[cpp]  view plain  copy

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

[cpp]  view plain  copy

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