有限狀態機FSM詳解及其實現

本文轉載自查看原文 2015-11-02 20:24 41662 算法

有限狀態機,也稱為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 }

View Code

通過Passive Data實現映射的FSM：

在如上的switch分支中，其使用類型大致相同，因此，我們可以考慮將相似的信息保存到一張表中，這樣就可以在程序中避免很多函數調用。在每個狀態中都使用一張轉換表來表示映射關系，轉換表的索引使用輸入字符來表示。此外，由於通過轉換表就可以描述不同狀態之間的變化，那么就沒有必要將每種狀態定義為一個類了，即不需要多余的繼承和虛函數了，僅使用一個State即可。

#include <limits.h>

class State
{
public:
    State();
    State* transition[range];
};

對於任意一個狀態state和輸入字符c，后續狀態都可以通過state.transition[c]來確定。

類Fsm中的成員state包含6個狀態，為了對應方便，我們將結束狀態放在state[0]中，每個狀態都使用一個三元組 { 當前狀態，輸入字符，下一個狀態 } 來表示：

struct TransGraph   // use triple to describe map
{
    int current_state;
    char input_char;
    int next_state;
};

如此，使用了轉換表代替了虛函數，簡化了程序的設計。

  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 }

View Code

通用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 }

View Code

當然也可以將上述程序中的轉換表不放在主程序中，而是由一個派生自Fsm的子類SpecificFsm提供，在SpecificFsm中設置具體的轉換表，然后通過SpecificFsm的初始化列表傳到基類Fsm中，這樣在主程序中就可以使用SpecificFsm來進行操作了。

免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。

猜您在找 有限狀態機FSM詳解及其實現有限狀態機FSM詳解及其實現 Lua FSM有限狀態機的實現有限狀態機（FSM）的設計與實現（一）有限狀態機（FSM）的設計與實現（二）【Java】4.0 有限狀態機（FSM） Unity FSM 有限狀態機 Unity中FSM有限狀態機有限狀態機(FSM)的Java 演示 Unity——有限狀態機FSM修改