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

Posted 2020-09-22

有限状态机,也称为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 }

•  通过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