一、狀態機描述

狀態機理論最初的發展在數字電路設計領域。在數字電路方面，根據輸出是否與輸入信號有關，狀態機可以劃分為Mealy型和Moore型狀態機；根據輸出是否與輸入信號同步，狀態機可以劃分為異步和同步狀態機。而在軟件設計領域，狀態機設計的理論儼然已經自成一體。Moore型狀態機的輸出只和當前狀態有關，和輸入無關，如果在軟件設計領域設計出這種類型的狀態機，則該狀態機接受的事件都是無內蘊信息的事件（輸入）。Mealy型狀態機的輸入是由當前狀態和輸入共同決定，對應到軟件設計領域，則該狀態機接收的事件含有內蘊信息，并且影響狀態機的輸出。顯然，這種劃分在軟件設計領域毫無意義。雖然軟件設計領域的狀態機也有同步和異步的劃分，但和數字電路方面的同步異步已經不同。

除了《數字電路》，涉及到狀態機的課程就是《編譯原理》了（本人屬計算機專業，其它專業是否涉及到狀態機就不清楚了）。下面簡單回顧一下《編譯原理》里有關有限狀態機的描述。在編譯原理課程里面，對有限狀態機的描述僅限在編譯領域，特定狀態，針對輸入字符，發生狀態改變，沒有額外的行為，另編譯原理里有限狀態機的構成要素，還包含唯一的初始狀態和一個終態集。數學語言描述如下：一個有限狀態機M是一個五元組，M=(K,E,T,S,Z)。其中（1)K是一個有窮集，其中的每個元素稱為狀態(2)E是一個有窮字母表，它的每個元素稱為一個輸入字符（3）T是轉換函數，是K×E->K上的映射(4)S是K中的元素，是唯一的一個初態（5） Z是K的一個子集，是一個終態集，或者叫結束集。很明顯，狀態機在編譯原理里的講解已經特化，輸入被定位為字符集，狀態改變的時候沒有額外動作發生。

與編譯原理中的狀態機不同，軟件設計領域中通用狀態機的輸入不是字符集，而是被稱作事件的結構（可以是結構體，也可以是類對象），并且特定的狀態下，針對發生的事件，不僅發生狀態改變，而且產生動作。借鑒編譯原理中狀態機的初始狀態和終態，通用狀態機的數學語言描述如下：一個通用有限狀態機M是一個七元組，M={K,E,T,M,F,S,Z}。其中（1）K是一個有窮集，其中的每個元素稱為狀態(2)E是一個有窮集，它的每個元素稱為一個事件（3）T是轉換函數，是K×E->K上的映射（4）M是一個有窮集，它的每個元素稱為動作（5）F是動作映射函數，是K×E->M上的映射（6)S是K中的元素，是唯一的一個初態（7） Z是K的一個子集，是一個終態集，或者叫結束集。實用的狀態機可以做進一步的優化，首先，可以把（3）（5）整合在一起，做一個K×E->{K,M}的映射，其次從實用性的角度出發，禁止狀態接收空事件（無輸入的情況下，狀態發生改變），作為彌補，為每個狀態增加進入動作和離開動作，第三，鑒于定時器在系統中，尤其是在狀態機中的重要性，可以為每個狀態增加定時器以及超時后的狀態轉換。本文后面的講述以及實現暫不考慮把定時器特化，如果需要，可以在狀態的進入動作中初始化定時器（另：關于定時器，以后會寫文章《系統設計之定時器》）。

二、狀態機分類（后文中如無特別說明，則狀態機指軟件設計領域的通用有限狀態機）

依據狀態之間是否有包含關系，分以下兩種

（1）常規狀態機。狀態機中的所有狀態是不相交的、互斥的。

（2）層次狀態機。狀態機中的狀態之間要么是互斥的，要么是真包含的，可以用樹性結構來描述這些狀態集，包含其它狀態的狀態稱為枝節點，不包含其它狀態的狀態稱為葉節點，為方便單樹描述，總是設計一個狀態包含所有的狀態節點，稱為根節點。狀態機的狀態只能停留在葉節點，而不能停留在枝節點，每個枝節點需要指定一個子節點為它的默認子節點，以便狀態機進入枝節點的時候能夠停留到葉節點。

三、狀態機實現

（1）switch/case if/else方式實現。用于少量狀態（3個及其以下）的時候，不需要引入專門的狀態機模塊。這種方式不能編寫通用的狀態機模塊，不再多說。

（2）面向過程方式：宏是實現面向過程方式的通用方式。雖然在狀態機層面還是可以用面向對象的方式封裝，這里還是把它稱為面向過程的方式。
1.常規狀態機模塊實現。這個狀態機涉及到機構由上而下為：

• 頂層結構是狀態機：當前狀態id，缺省操作，狀態表，
• 狀態表：狀態數組
• 狀態結構：狀態id，狀態名，進入操作，退出操作，缺省操作，狀態事件表（數組）
• 狀態事件結構：操作，事件，下一狀態的id

狀態機的算法是由狀態機的結構決定的。實現如下：

#define SINGLE_STATE_MAX_EVENT 10
typedef int FSM_EVENT_ID;
typedef struct event_param_st
{
    FSM_EVENT_ID id;
    union{
        int i;
    }data;
}FSM_EVENT;
typedef int FSM_STATE_ID;
typedef void (*FSM_FUNC)(FSM_EVENT *);
typedef struct state_event_st
{
    FSM_FUNC func;
    FSM_EVENT_ID event;
    FSM_STATE_ID state;
}FSM_STATE_EVENT;
typedef struct state_st
{
    FSM_STATE_ID id;
    char *name;
    FSM_FUNC enter_func;
    FSM_FUNC exit_func;
    FSM_FUNC default_func;
    FSM_STATE_EVENT event_table[SINGLE_STATE_MAX_EVENT];
}FSM_STATE;
typedef FSM_STATE STATE_TABLE[];
typedef FSM_STATE * PTR_STATE_TABLE;
#define END_EVENT_ID -1
#define END_STATE_ID -1
#define BEGIN_FSM_STATE_TABLE(state_stable) static STATE_TABLE state_stable={
#define BEGIN_STATE(id,name,enter_func,exit_func,default_func) {id,name,enter_func,exit_func,default_func,{
#define STATE_EVENT_ITEM(func,event,state) {func,event,state},
#define END_STATE(id) {NULL,END_EVENT_ID,END_STATE_ID}}},
#define END_FSM_STATE_TABLE(state_stable) {END_STATE_ID,NULL,NULL,NULL,NULL,NULL}};

typedef struct fsm_st
{
    FSM_STATE_ID state_id;
    FSM_FUNC default_func;
    PTR_STATE_TABLE state_tables;
   
}FSM;

void fsm_do_event(FSM &fsm, FSM_EVENT &event)
{
    FSM_STATE *state=&(fsm.state_tables[fsm.state_id]);
    int i=0;
    while(state->event_table[i].event!=END_EVENT_ID)
    {
        if(state->event_table[i].event==event.id)
            break;
        i++;
    }
    if(state->event_table[i].event!=END_EVENT_ID)
    {
        if(state->id!=state->event_table[i].state)
        {
            if(state->exit_func )
                state->exit_func(&event);
        }
        if(state->event_table[i].func)
            state->event_table[i].func(&event);

        if(state->id!=state->event_table[i].state)
        {
            if(fsm.state_tables[state->event_table[i].state].enter_func)
                fsm.state_tables[state->event_table[i].state].enter_func(&event);
            fsm.state_id=state->event_table[i].state;
        }
    }
    else
    {
        if(state->default_func)
            state->default_func(&event);
        else
        {
            if(fsm.default_func)
                fsm.default_func(&event);
        }
    }
}

以上說明實現原理，有特殊需要的話可以自己定制狀態機，比如上面的狀態事件表數組的上限取的是單個狀態中事件項的最大值，也可以定義為所有事件的個數，這樣的話事件也不需要查詢，可以象狀態樣直接定位，只是狀態事件表會浪費一些存儲空間。上面的FSM_EVENT僅僅是個例子，實際開發根據需要定義不同的union。上面的算法也是假定狀態表的狀態定義是從0開始，順序遞增的。

對外部調用而言，最后的狀態機結構和事件執行的方法可以封裝為對象。下面舉例說明狀態機的定義(事件和狀態都應該是enum類型，這里直接使用數字，僅為說明問題而已)。

BEGIN_FSM_STATE_TABLE(my_state_table)
    BEGIN_STATE(0,"first",enter_fsm,exit_fsm,defualt_fsm)
        STATE_EVENT_ITEM(func_fsm,1,1)
        STATE_EVENT_ITEM(func_fsm,2,2)
    END_STATE(0)
   
    BEGIN_STATE(1,"second",enter_fsm,exit_fsm,defualt_fsm)
        STATE_EVENT_ITEM(func_fsm,1,2)
        STATE_EVENT_ITEM(func_fsm,2,0)
    END_STATE(1)
   
    BEGIN_STATE(2,"third",enter_fsm,exit_fsm,defualt_fsm)
        STATE_EVENT_ITEM(func_fsm,1,0)
        STATE_EVENT_ITEM(func_fsm,2,1)
    END_STATE(2)
END_FSM_STATE_TABLE(my_state_table)

void enter_fsm(FSM_EVENT * event)
{
    printf("enter me\n");
}
void exit_fsm(FSM_EVENT * event)
{
    printf("exit me\n");
}
void defualt_fsm(FSM_EVENT * event)
{
    printf("i am defualt_fsm\n");
}
void func_fsm(FSM_EVENT * event)
{
    printf("i am func_fsm\n");
}
int main()
{
    printf("i am main\n");
    FSM fsm={0,defualt_fsm,my_state_table};
    printf("state[%d],name[%s]\n",fsm.state_id,fsm.state_tables[fsm.state_id].name);
    FSM_EVENT event;
    event.id=1;
    event.data.i=1;
    fsm_do_event(fsm,event);
    printf("state[%d],name[%s]\n",fsm.state_id,fsm.state_tables[fsm.state_id].name);
}