c++写状态机

用c++的状态模式写状态机
状态是固定的，事件可扩展
由事件触发，然后根据状态有不同的处理

状态表

	空闲	对接中	对接成功	对接失败	补给中	补给成功	补给失败	停止补给中	停止补给成功	停止补给失败	断开对接中
对接事件
断开对接事件
补给事件
停止补给事件

代码
fsm.h

#ifndef FSM_H
#define FSM_H

#include <unordered_map>

// 事件
enum {
     CONNECT_EVENT     = 1,             // 连接事件
     DISCONNECT_EVENT  = 2,             // 断开连接
     SUPPLY_EVENT      = 3,             // 补给事件
     STOP_SUPPLY_EVENT = 4,             // 停止补给
};

// 状态
enum {
    IDLE_STATE = 0,                     // 空闲
    
    CONNECTING_STATE,                   // 对接中
    CONNECT_SUCCESS_STATE,              // 对接成功
    CONNECT_FAIL_STATE,                 // 对接失败

    SUPPLYING_STATE,                    // 补给中
    SUPPLY_SUCCESS_STATE,               // 补给成功
    SUPPLY_FAIL_STATE,                  // 补给失败

    STOP_SUPPLYING_STATE,               // 停止补给中
    STOP_SUPPLY_SUCCESS_STATE,          // 停止补给成功
    STOP_SUPPLY_FAIL_STATE,             // 停止补给失败

    DISCONNECTING_STATE,                // 断开对接中
};

class Event;

// FSM类管理事件处理
// 事件类管理状态处理
class FSM
{
public:
    bool RegisterEvent(int event, Event *pEvent);       // 注册新的事件
    bool StateTrans(int newState);                      // 需要状态转移则调用此函数
    void EventTick(int event);                          // 根据事件，调用对应的事件类处理函数去处理
    int GetCurState();                                  // 获取当前状态
    void SetInitState(int state);                       // 设置初始状态

private:
    std::unordered_map<int, Event*> all_event;          // 参数1事件，参数2对应事件类
    int cur_state;                                      // 当前状态
};

// 事件的基类
class Event
{
public:
    
    
    virtual void init() = 0;
    virtual void OnEventEnter() = 0;                        
    virtual void OnEventHandle(int cur_state) = 0;
    virtual void OnEventExit() = 0;
    Event(FSM *_fsm)
    {
        fsm = _fsm;
    }
protected:
    FSM* fsm = nullptr;
};
#endif // FSM_H

fsm.cpp

#include "fsm.h"

// 注册新的事件
bool FSM::RegisterEvent(int event, Event *pEvent)
{
    all_event[event] = pEvent;
    return true;
}

// 需要状态转移则调用此函数
bool FSM::StateTrans(int newState)
{
    cur_state = newState;
    return true;
}

// 根据事件，调用对应的事件类处理函数去处理
void FSM::EventTick(int event)
{
    all_event[event]->OnEventHandle(cur_state);
}

// 获取当前状态
int FSM::GetCurState()
{
    return cur_state;
}

// 设置初始状态
void FSM::SetInitState(int state)
{
    cur_state = state;
}

event_connect.h

#ifndef EVENT_CONNECT_H
#define EVENT_CONNECT_H

#include "fsm.h"

// 连接事件
class ConnectEvent : public Event
{
public:
    ConnectEvent(FSM* fsm);
    void init();                                                    // 初始化，对应状态和处理函数的映射

    int connect();
    int connecting();
    int connect_success();

    void OnEventEnter();
    void OnEventHandle(int cur_state);
    void OnEventExit();

private:
    std::unordered_map<int, int(ConnectEvent::*)()> e_state;        // 参数1是状态，参数2是处理函数
};

// 断开连接事件
class DisconnectEvent : public Event
{
public:
    DisconnectEvent(FSM* fsm);
    void init();                                                    // 初始化，对应状态和处理函数的映射

    int disconnect();
    int disconnecting();
    int disconnect_success();

    void OnEventEnter();
    void OnEventHandle(int cur_state);
    void OnEventExit();

private:
    std::unordered_map<int, int(DisconnectEvent::*)()> e_state;     // 参数1是状态，参数2是处理函数
};

#endif // EVENT_CONNECT_H

event_connect.cpp

#include <iostream>
#include <unistd.h>
#include "event_connect.h"

using namespace std;

ConnectEvent::ConnectEvent(FSM* fsm) : Event(fsm) 
{
    init();
}

// 初始化，对应状态和处理函数的映射
void ConnectEvent::init()
{
    e_state[IDLE_STATE]                 = &ConnectEvent::connect;
    e_state[CONNECTING_STATE]           = &ConnectEvent::connecting;
    e_state[CONNECT_SUCCESS_STATE]      = &ConnectEvent::connect_success;
    e_state[CONNECT_FAIL_STATE]         = &ConnectEvent::connect;
    e_state[SUPPLYING_STATE]            = &ConnectEvent::connect_success;
    e_state[SUPPLY_SUCCESS_STATE]       = &ConnectEvent::connect_success;
    e_state[SUPPLY_FAIL_STATE]          = &ConnectEvent::connect_success;
    e_state[STOP_SUPPLYING_STATE]       = &ConnectEvent::connect_success;
    e_state[STOP_SUPPLY_SUCCESS_STATE]  = &ConnectEvent::connect_success;
    e_state[STOP_SUPPLY_FAIL_STATE]     = &ConnectEvent::connect_success;
    e_state[DISCONNECTING_STATE]        = &ConnectEvent::connect_success;
}

// 连接处理
int ConnectEvent::connect()
{   
    cout << "connect start" << endl;
    fsm->StateTrans(CONNECTING_STATE);
    sleep(3);
    fsm->StateTrans(CONNECT_SUCCESS_STATE);
    cout << "connect success" << endl;
    return 0;
}

// 连接中处理
int ConnectEvent::connecting()
{
    cout << "connecting" << endl;
    return 0;
}

// 连接成功处理
int ConnectEvent::connect_success()
{
    cout << "connect_success" << endl;
    return 0;
}

// 事件资源申请处理
void ConnectEvent::OnEventEnter() 
{
    cout << "---- ConnectEvent Enter" << endl;
}

// 事件处理
void ConnectEvent::OnEventHandle(int cur_state) 
{
    cout << "OnEventHandle cur state: " << cur_state << endl;
    OnEventEnter();

    (this->*e_state[cur_state])();                  // 不加this会编译出错

    OnEventExit();
    return ;  
}

// 事件资源释放处理
void ConnectEvent::OnEventExit() 
{ 
    cout << "==== ConnectEvent Exit" << endl; 
}





DisconnectEvent::DisconnectEvent(FSM* fsm) : Event(fsm) 
{
    init();
}

// 初始化，对应状态和处理函数的映射
void DisconnectEvent::init()
{
    e_state[IDLE_STATE]                 = &DisconnectEvent::disconnect_success;
    e_state[CONNECTING_STATE]           = &DisconnectEvent::disconnect;
    e_state[CONNECT_SUCCESS_STATE]      = &DisconnectEvent::disconnect;
    e_state[CONNECT_FAIL_STATE]         = &DisconnectEvent::disconnect_success;
    e_state[SUPPLYING_STATE]            = &DisconnectEvent::disconnect;
    e_state[SUPPLY_SUCCESS_STATE]       = &DisconnectEvent::disconnect;
    e_state[SUPPLY_FAIL_STATE]          = &DisconnectEvent::disconnect;
    e_state[STOP_SUPPLYING_STATE]       = &DisconnectEvent::disconnect;
    e_state[STOP_SUPPLY_SUCCESS_STATE]  = &DisconnectEvent::disconnect;
    e_state[STOP_SUPPLY_FAIL_STATE]     = &DisconnectEvent::disconnect;
    e_state[DISCONNECTING_STATE]        = &DisconnectEvent::disconnecting;
}

// 断开连接处理
int DisconnectEvent::disconnect()
{   
    cout << "disconnect start" << endl;
    fsm->StateTrans(DISCONNECTING_STATE);
    sleep(3);
    fsm->StateTrans(IDLE_STATE);
    cout << "disconnect success" << endl;
    return 0;
}

// 断开连接中处理
int DisconnectEvent::disconnecting()
{
    cout << "disconnecting" << endl;
    return 0;
}

// 断开连接成功处理
int DisconnectEvent::disconnect_success()
{
    cout << "disconnect_success" << endl;
    return 0;
}

// 事件资源申请处理
void DisconnectEvent::OnEventEnter() 
{
    cout << "---- DisconnectEvent Enter" << endl;
}

// 事件处理
void DisconnectEvent::OnEventHandle(int cur_state) 
{
    cout << "OnEventHandle cur state: " << cur_state << endl;
    OnEventEnter();

    (this->*e_state[cur_state])();                  // 不加this会编译出错

    OnEventExit();
    return ;  
}

// 事件资源释放处理
void DisconnectEvent::OnEventExit() 
{ 
    cout << "==== DisconnectEvent Exit" << endl; 
}

event_supply.h

#ifndef EVENT_SUPPLY_H
#define EVENT_SUPPLY_H

#include "fsm.h"

// 补给事件
class SupplyEvent : public Event
{
public:
    SupplyEvent(FSM* fsm);
    void init();                                                    // 初始化，对应状态和处理函数的映射

    int supply();
    int supplying();
    int supply_success();
    int not_allow_supply();

    void OnEventEnter();
    void OnEventHandle(int cur_state);
    void OnEventExit();

private:
    std::unordered_map<int, int(SupplyEvent::*)()> e_state;         // 参数1是状态，参数2是处理函数
};

// 停止补给事件
class StopSupplyEvent : public Event
{
public:
    StopSupplyEvent(FSM* fsm);
    void init();                                                    // 初始化，对应状态和处理函数的映射

    int stop_supply();
    int stop_supplying();
    int stop_supply_success();
    int not_allow_stop_supply();

    void OnEventEnter();
    void OnEventHandle(int cur_state);
    void OnEventExit();

private:
    std::unordered_map<int, int(StopSupplyEvent::*)()> e_state;     // 参数1是状态，参数2是处理函数
};

#endif // EVENT_SUPPLY_H

event_supply.cpp

#include <iostream>
#include <unistd.h>
#include "event_supply.h"

using namespace std;

SupplyEvent::SupplyEvent(FSM* fsm) : Event(fsm) 
{
    init();
}

// 初始化，对应状态和处理函数的映射
void SupplyEvent::init()
{
    e_state[IDLE_STATE]                 = &SupplyEvent::not_allow_supply;
    e_state[CONNECTING_STATE]           = &SupplyEvent::not_allow_supply;
    e_state[CONNECT_SUCCESS_STATE]      = &SupplyEvent::supply;
    e_state[CONNECT_FAIL_STATE]         = &SupplyEvent::not_allow_supply;
    e_state[SUPPLYING_STATE]            = &SupplyEvent::supplying;
    e_state[SUPPLY_SUCCESS_STATE]       = &SupplyEvent::supply_success;
    e_state[SUPPLY_FAIL_STATE]          = &SupplyEvent::supply;
    e_state[STOP_SUPPLYING_STATE]       = &SupplyEvent::not_allow_supply;
    e_state[STOP_SUPPLY_SUCCESS_STATE]  = &SupplyEvent::supply_success;
    e_state[STOP_SUPPLY_FAIL_STATE]     = &SupplyEvent::supply;
    e_state[DISCONNECTING_STATE]        = &SupplyEvent::not_allow_supply;
}

// 补给处理
int SupplyEvent::supply()
{   
    cout << "supply start" << endl;
    fsm->StateTrans(SUPPLYING_STATE);
    sleep(3);
    fsm->StateTrans(SUPPLY_SUCCESS_STATE);
    cout << "supply success" << endl;
    return 0;
}

// 补给中处理
int SupplyEvent::supplying()
{
    cout << "supplying" << endl;
    return 0;
}

// 补给成功处理
int SupplyEvent::supply_success()
{
    cout << "supply_success" << endl;
    return 0;
}

// 不能补给处理
int SupplyEvent::not_allow_supply()
{
    cout << "not_allow_supply" << endl;
    return 0;
}

// 事件资源申请处理
void SupplyEvent::OnEventEnter() 
{
    cout << "---- SupplyEvent Enter" << endl;
}

// 事件处理
void SupplyEvent::OnEventHandle(int cur_state) 
{
    cout << "OnEventHandle cur state: " << cur_state << endl;
    OnEventEnter();

    (this->*e_state[cur_state])();                  // 不加this会编译出错

    OnEventExit();
    return ;  
}

// 事件资源释放处理
void SupplyEvent::OnEventExit() 
{ 
    cout << "==== SupplyEvent Exit" << endl; 
}




StopSupplyEvent::StopSupplyEvent(FSM* fsm) : Event(fsm) 
{
    init();
}

// 初始化，对应状态和处理函数的映射
void StopSupplyEvent::init()
{
    e_state[IDLE_STATE]                 = &StopSupplyEvent::not_allow_stop_supply;
    e_state[CONNECTING_STATE]           = &StopSupplyEvent::not_allow_stop_supply;
    e_state[CONNECT_SUCCESS_STATE]      = &StopSupplyEvent::not_allow_stop_supply;
    e_state[CONNECT_FAIL_STATE]         = &StopSupplyEvent::not_allow_stop_supply;
    e_state[SUPPLYING_STATE]            = &StopSupplyEvent::stop_supply;
    e_state[SUPPLY_SUCCESS_STATE]       = &StopSupplyEvent::stop_supply;
    e_state[SUPPLY_FAIL_STATE]          = &StopSupplyEvent::stop_supply;
    e_state[STOP_SUPPLYING_STATE]       = &StopSupplyEvent::stop_supplying;
    e_state[STOP_SUPPLY_SUCCESS_STATE]  = &StopSupplyEvent::stop_supply_success;
    e_state[STOP_SUPPLY_FAIL_STATE]     = &StopSupplyEvent::stop_supply;
    e_state[DISCONNECTING_STATE]        = &StopSupplyEvent::not_allow_stop_supply;
}

// 补给处理
int StopSupplyEvent::stop_supply()
{   
    cout << "stop_supply start" << endl;
    fsm->StateTrans(STOP_SUPPLYING_STATE);
    sleep(3);
    fsm->StateTrans(STOP_SUPPLY_SUCCESS_STATE);
    cout << "stop_supply success" << endl;
    return 0;
}

// 补给中处理
int StopSupplyEvent::stop_supplying()
{
    cout << "stop_supplying" << endl;
    return 0;
}

// 补给成功处理
int StopSupplyEvent::stop_supply_success()
{
    cout << "stop_supply_success" << endl;
    return 0;
}

// 不能补给处理
int StopSupplyEvent::not_allow_stop_supply()
{
    cout << "not_allow_supply" << endl;
    return 0;
}

// 事件资源申请处理
void StopSupplyEvent::OnEventEnter() 
{
    cout << "---- StopSupplyEvent Enter" << endl;
}

// 事件处理
void StopSupplyEvent::OnEventHandle(int cur_state) 
{
    cout << "OnEventHandle cur state: " << cur_state << endl;
    OnEventEnter();

    (this->*e_state[cur_state])();                  // 不加this会编译出错

    OnEventExit();
    return ;  
}

// 事件资源释放处理
void StopSupplyEvent::OnEventExit() 
{ 
    cout << "==== StopSupplyEvent Exit" << endl; 
}

main.cpp

/************************************************************************************
* 状态是固定的，事件是可扩展的
* 状态模式实现状态机
* 状态机类管理状态转换，以及状态处理调用
* 事件业务逻辑处理类
* 
*                 空闲  对接中  对接成功  对接失败  补给中  补给成功  补给失败  停止补给中  停止补给成功  停止补给失败  断开对接中
* 对接事件
* 断开对接事件
* 补给事件
* 停止补给事件
*************************************************************************************/

#include <iostream>

#include "event_connect.h"
#include "event_supply.h"

int main()
{
    // 构造状态机
    FSM* fsm = new FSM();
    fsm->SetInitState(IDLE_STATE);

    Event* connect_e = new ConnectEvent(fsm);
    Event* disconnect_e = new DisconnectEvent(fsm);
    Event* supply_e = new SupplyEvent(fsm);
    Event* stop_supply_e = new StopSupplyEvent(fsm);

    fsm->RegisterEvent(CONNECT_EVENT, connect_e);
    fsm->RegisterEvent(DISCONNECT_EVENT, disconnect_e);
    fsm->RegisterEvent(SUPPLY_EVENT, supply_e);
    fsm->RegisterEvent(STOP_SUPPLY_EVENT, stop_supply_e);

    fsm->EventTick(CONNECT_EVENT);
    fsm->EventTick(CONNECT_EVENT);
    fsm->EventTick(SUPPLY_EVENT);
    fsm->EventTick(STOP_SUPPLY_EVENT);

    fsm->EventTick(DISCONNECT_EVENT);

    std::cout << "cur state: " << fsm->GetCurState() << std::endl;

    return 0;
}

Makefile

all : main.o fsm.o event_connect.o event_supply.o
	g++ -std=c++11 -o main -I ./ main.o fsm.o event_connect.o event_supply.o

main.o : main.cpp
	g++ -std=c++11 -c -I ./ main.cpp
fsm.o : fsm.cpp 
	g++ -std=c++11 -c fsm.cpp
event_connect.o : event_connect.cpp 
	g++ -std=c++11 -c -I ./ event_connect.cpp
event_supply.o : event_supply.cpp 
	g++ -std=c++11 -c -I ./ event_supply.cpp

clean : 
	rm -f *.o main 

执行结果打印