一个简单的有限状态机的实现

1. #include <iostream>
3. using namespace std;
5. class Door
6. {
7. public:
8.     virtual void open() {
9.         cout<<"Door Opening...!"<<endl;
10.     }
11.     virtual void close() {
12.         cout<<"Door Closing...!"<<endl;
13.     }
14. };
16. //forward decl
17. class OpenState;
18. class ClosedState;
20. class DoorFSM;
22. class DoorState
23. {
24. public:
25.     virtual void open_door(DoorFSM *pfsm) = 0;
26.     virtual void close_door(DoorFSM *pfsm) = 0;
27. };
29. class DoorFSM : public Door
30. {
31. public:
32.     DoorFSM(DoorState *pInitState);
34.     void open_door();
35.     void close_door();
36.     void setState(DoorState* pState);
37. private:
38.     DoorState *m_State;
39. };
41. class OpenState : public DoorState
42. {
43. public:
44.     static DoorState* InstancePtr()
45.     {
46.         if (!m_instance) {
47.             m_instance = new OpenState();
48.         }
49.         return m_instance;
50.     }
52.     virtual void open_door(DoorFSM *pfsm);
53.     virtual void close_door(DoorFSM *pfsm);
54. protected:
55.     OpenState() {}
56.     static OpenState* m_instance;
57. };
59. OpenState* OpenState::m_instance = NULL;
61. class ClosedState : public DoorState
62. {
63. public:
64.     static DoorState* InstancePtr()
65.     {
66.         if (!m_instance) {
67.             m_instance = new ClosedState();
68.         }
69.         return m_instance;
70.     }
72.     virtual void open_door(DoorFSM *pfsm);
73.     virtual void close_door(DoorFSM *pfsm);
74. protected:
75.     ClosedState() {}
76.     static ClosedState* m_instance;
77. };
79. ClosedState* ClosedState::m_instance = NULL;
81. void OpenState::open_door(DoorFSM *pfsm)
82. {
83.     //open open
84. }
86. void OpenState::close_door(DoorFSM *pfsm)
87. {
88.     pfsm->setState(ClosedState::InstancePtr());
89.     pfsm->close();
90. }
92. void ClosedState::open_door(DoorFSM *pfsm)
93. {
94.     pfsm->setState(OpenState::InstancePtr());
95.     pfsm->open();
96. }
98. void ClosedState::close_door(DoorFSM *pfsm)
99. {
100.     //closed close
101. }
103. //implement FSM part below
104. DoorFSM::DoorFSM(DoorState *pInitState)
105. :m_State(pInitState)
106. {}
108. void DoorFSM::open_door()
109. {
110.     m_State->open_door(this);
111. }
113. void DoorFSM::close_door()
114. {
115.     m_State->close_door(this);
116. }
118. void DoorFSM::setState(DoorState *pState)
119. {
120.     m_State = pState;
121. }
123. int main(int argc, char *argv[])
124. {
125.     DoorFSM fsm(ClosedState::InstancePtr());
126.     
127.     fsm.close_door();
128.     fsm.open_door();
129.     fsm.open_door();
130.     fsm.close_door();
131.     
132.     cout<<"seprate line........"<<endl;
133.     
134.     DoorFSM fsm2(OpenState::InstancePtr());
135.     fsm2.close_door();
136.     fsm2.open_door();
137.     fsm2.open_door();
138.     fsm2.close_door();
139.     
140.     cin.get();
141.     return 0;
142. }