简单状态机按照如下工作流程： 它包括一个初始化伪状态，一个正常状态和一个结束状态。如下代码是上述图表中流程的一种实现。
#include <iostream> #include <boost/msm/back/state_machine.hpp> #include <boost/msm/front/state_machine_def.hpp> #include <boost/msm/front/functor_row.hpp> namespace { namespace msm = boost::msm; namespace msmf = boost::msm::front; namespace mpl = boost::mpl; // ----- Events struct Event1 {}; // ----- State machine struct Sm1_:msmf::state_machine_def<Sm1_> { // States struct State1:msmf::state<> { // Entry action template <class Event,class Fsm> void on_entry(Event const&, Fsm&) const { std::cout << "State1::on_entry()" << std::endl; } // Exit action template <class Event,class Fsm> void on_exit(Event const&, Fsm&) const { std::cout << "State1::on_exit()" << std::endl; } }; struct End:msmf::terminate_state<> {}; // Set initial state typedef State1 initial_state; // Transition table struct transition_table:mpl::vector< // Start Event Next Action Guard msmf::Row < State1, Event1, End, msmf::none, msmf::none > > {}; }; // Pick a back-end typedef msm::back::state_machine<Sm1_> Sm1; void test() { Sm1 sm1; sm1.start(); std::cout << "> Send Event1" << std::endl; sm1.process_event(Event1()); } } int main() { test(); return 0; } // Output: // // State1::on_entry() // > Send Event1 // State1::on_exit()Sm1_ 是一个状态机的定义，在 Sm1_，有两个状态，state1 和 End。初始伪状态是定义在一下代码行： typedef State1 initial_state; 此初始状态类型定义意味着状态机 Sm1 从状态 State1 开始。
考虑如下图表：
从初始状态转变到 State1 有一个动作。为了实现这种类型的状态机，你需要额外的代码。
A transition from an initial pseudo state to State1 has an action. To implement this kind of state machine, you need additional codes.
如下图表和代码展示了如何实现一个初始状态转变的动作： 在如下代码片段中，此初始状态类型定义仅仅表明状态机从State1开始，此初始状态定义并没有引入一个初始伪状态。
// Set initial state typedef State1 initial_state;为了实现从 State1 和 初始伪状态转换的转换动作，需要在代码中定义初始伪状态。Boost.Msm 不能直接支持初始伪状态，但是可以用一个正常状态来替代。则将原始图表改写为如下图表： 你不必写此模型，此模型的目的在于帮助你更好理解下面的代码的实现过程：
#include <iostream> #include <boost/msm/back/state_machine.hpp> #include <boost/msm/front/state_machine_def.hpp> #include <boost/msm/front/functor_row.hpp> namespace { namespace msm = boost::msm; namespace msmf = boost::msm::front; namespace mpl = boost::mpl; // ----- Events struct Event1 {}; // ----- State machine struct Sm1_:msmf::state_machine_def<Sm1_> { // States struct Init:msmf::state<> {}; struct State1:msmf::state<> { // Entry action template <class Event,class Fsm> void on_entry(Event const&, Fsm&) { std::cout << "State1::on_entry()" << std::endl; } // Exit action template <class Event,class Fsm> void on_exit(Event const&, Fsm&) { std::cout << "State1::on_exit()" << std::endl; } }; // Set initial state typedef Init initial_state; // Actions struct InitAction { template <class Event, class Fsm, class SourceState, class TargetState> void operator()(Event const&, Fsm&, SourceState&, TargetState&) const { std::cout << "InitAction()" << std::endl; } }; // Transition table struct transition_table:mpl::vector< // Start Event Next Action Guard msmf::Row < Init, msmf::none, State1, InitAction, msmf::none >, msmf::Row < State1, Event1, State1, msmf::none, msmf::none > > {}; }; // Pick a back-end typedef msm::back::state_machine<Sm1_> Sm1; void test() { Sm1 sm1; sm1.start(); std::cout << "> Send Event1" << std::endl; sm1.process_event(Event1()); } } int main() { test(); return 0; } // Output: // // InitAction() // State1::on_entry() // > Send Event1 // State1::on_exit() // State1::on_entry()看下面代码行： msmf::Row < Init, msmf::none, State1, InitAction, msmf::none >, 这是一个状态转换表行。这里最重要的是其事件为msmf::none。这意味着当状态机处于Init状态时，自动触发从 Init 到 state1 的转换。
Boost.Msm的事件句柄能够重载。on_entry 和 on_exit 动作的句柄可以通过事件类型匹配。守卫条件和动作因子能够通过 Event，SourceState 和 TargetState 来匹配。
让我们看如下图表：
所有的转变都有同样的守卫条件和动作因子。 以上图表的代码实现如下：
#include <iostream> #include <boost/msm/back/state_machine.hpp> #include <boost/msm/front/state_machine_def.hpp> #include <boost/msm/front/functor_row.hpp> namespace { namespace msm = boost::msm; namespace msmf = boost::msm::front; namespace mpl = boost::mpl; // ----- Events struct Event1 {}; struct Event2 {}; struct InitialEvent {}; // ----- State machine struct Sm1_:msm::front::state_machine_def<Sm1_> { typedef InitialEvent initial_event; // States struct State1:msm::front::state<> { // Entry action template <class Fsm> void on_entry(InitialEvent const&, Fsm&) const { std::cout << "State1::on_entry(InitialEvent)" << std::endl; } template <class Fsm> void on_entry(Event1 const&, Fsm&) const { std::cout << "State1::on_entry(Event1)" << std::endl; } template <class Fsm> void on_entry(Event2 const&, Fsm&) const { std::cout << "State1::on_entry(Event2)" << std::endl; } // Exit action template <class Fsm> void on_exit(Event1 const&, Fsm&) const { std::cout << "State1::on_exit(Event1)" << std::endl; } template <class Fsm> void on_exit(Event2 const&, Fsm&) const { std::cout << "State1::on_exit(Event2)" << std::endl; } }; struct State2:msm::front::state<> { // Entry action template <class Fsm> void on_entry(Event1 const&, Fsm&) const { std::cout << "State2::on_entry(Event1)" << std::endl; } template <class Fsm> void on_entry(Event2 const&, Fsm&) const { std::cout << "State2::on_entry(Event2)" << std::endl; } // Exit action template <class Fsm> void on_exit(Event1 const&, Fsm&) const { std::cout << "State2::on_exit(Event1)" << std::endl; } template <class Fsm> void on_exit(Event2 const&, Fsm&) const { std::cout << "State2::on_exit(Event2)" << std::endl; } }; struct Action1 { template <class Fsm> void operator()(Event1 const& e, Fsm&, State1&, State2&) const { std::cout << "Action1(Event1, Fsm, State1, State2)" << std::endl; } template <class Fsm> void operator()(Event2 const& e, Fsm&, State1&, State2&) const { std::cout << "Action1(Event2, Fsm, State1, State2)" << std::endl; } template <class Fsm> void operator()(Event1 const& e, Fsm&, State2&, State1&) const { std::cout << "Action1(Event1, Fsm, State2, State1)" << std::endl; } template <class Fsm> void operator()(Event2 const& e, Fsm&, State2&, State1&) const { std::cout << "Action1(Event2, Fsm, State2, State1)" << std::endl; } }; struct Guard1 { template <class Fsm> bool operator()(Event1 const& e, Fsm&, State1&, State2&) const { std::cout << "Guard1(Event1, Fsm, State1, State2)" << std::endl; return true; } template <class Fsm> bool operator()(Event2 const& e, Fsm&, State1&, State2&) const { std::cout << "Guard1(Event2, Fsm, State1, State2)" << std::endl; return true; } template <class Fsm> bool operator()(Event1 const& e, Fsm&, State2&, State1&) const { std::cout << "Guard1(Event1, Fsm, State2, State1)" << std::endl; return true; } template <class Fsm> bool operator()(Event2 const& e, Fsm&, State2&, State1&) const { std::cout << "Guard1(Event2, Fsm, State2, State1)" << std::endl; return true; } }; // Set initial state typedef State1 initial_state; // Transition table struct transition_table:mpl::vector< // Start Event Next Action Guard msmf::Row < State1, Event1, State2, Action1, Guard1 >, msmf::Row < State1, Event2, State2, Action1, Guard1 >, msmf::Row < State2, Event1, State1, Action1, Guard1 >, msmf::Row < State2, Event2, State1, Action1, Guard1 > > {}; }; // Pick a back-end typedef msm::back::state_machine<Sm1_> Sm1; void test() { Sm1 sm1; sm1.start(); std::cout << "> Send Event1" << std::endl; sm1.process_event(Event1()); std::cout << "> Send Event1" << std::endl; sm1.process_event(Event1()); std::cout << "> Send Event2" << std::endl; sm1.process_event(Event2()); std::cout << "> Send Event2" << std::endl; sm1.process_event(Event2()); } } int main() { test(); return 0; } // Output: // // State1::on_entry(InitialEvent) // > Send Event1 // Guard1(Event1, Fsm, State1, State2) // State1::on_exit(Event1) // Action1(Event1, Fsm, State1, State2) // State2::on_entry(Event1) // > Send Event1 // Guard1(Event1, Fsm, State2, State1) // State2::on_exit(Event1) // Action1(Event1, Fsm, State2, State1) // State1::on_entry(Event1) // > Send Event2 // Guard1(Event2, Fsm, State1, State2) // State1::on_exit(Event2) // Action1(Event2, Fsm, State1, State2) // State2::on_entry(Event2) // > Send Event2 // Guard1(Event2, Fsm, State2, State1) // State2::on_exit(Event2) // Action1(Event2, Fsm, State2, State1) // State1::on_entry(Event2)当你不想关心具体的事件、原状态和目标状态时，你能用如下模板参数：
struct State1:msm::front::state<> { // Entry action template <class Event,class Fsm> void on_entry(Event const&, Fsm&) const { std::cout << "State1::on_entry()" << std::endl; } }; // Actions struct Action1 { template <class Event, class Fsm, class SourceState, class TargetState> void operator()(Event const&, Fsm&, SourceState&, TargetState&) const { std::cout << "Action1()" << std::endl; } }Event1/Action1 是一个自转变，Event2/Action2 是一个内部转变。当内部转变发生时，entry 和 exit 动作不会被调用。与此对比，自转变会引起 entry 和 exit 的调用。
#include <iostream> #include <boost/msm/back/state_machine.hpp> #include <boost/msm/front/state_machine_def.hpp> #include <boost/msm/front/functor_row.hpp> namespace { namespace msm = boost::msm; namespace msmf = boost::msm::front; namespace mpl = boost::mpl; // ----- Events struct Event1 {}; struct Event2 {}; // ----- State machine struct Sm1_:msmf::state_machine_def<Sm1_> { // States struct State1:msmf::state<> { // Entry action template <class Event,class Fsm> void on_entry(Event const&, Fsm&) const { std::cout << "State1::on_entry()" << std::endl; } // Exit action template <class Event,class Fsm> void on_exit(Event const&, Fsm&) const { std::cout << "State1::on_exit()" << std::endl; } }; // Set initial state typedef State1 initial_state; // Actions struct Action1 { template <class Event, class Fsm, class SourceState, class TargetState> void operator()(Event const&, Fsm&, SourceState&, TargetState&) const { std::cout << "Action1()" << std::endl; } }; struct Action2 { template <class Event, class Fsm, class SourceState, class TargetState> void operator()(Event const&, Fsm&, SourceState&, TargetState&) const { std::cout << "Action2()" << std::endl; } }; // Transition table struct transition_table:mpl::vector< // Start Event Next Action Guard msmf::Row < State1, Event1, State1, Action1, msmf::none >, msmf::Row < State1, Event2, msmf::none, Action2, msmf::none > > {}; }; // Pick a back-end typedef msm::back::state_machine<Sm1_> Sm1; void test() { Sm1 sm1; sm1.start(); std::cout << "> Send Event1" << std::endl; sm1.process_event(Event1()); std::cout << "> Send Event2" << std::endl; sm1.process_event(Event2()); } } int main() { test(); return 0; } // Output: // // State1::on_entry() // > Send Event1 // State1::on_exit() // Action1() // State1::on_entry() // > Send Event2 // Action2()为了描述自转变，设置 Start 和 Next 为同样的状态在状态转换表中。而对于内部转变，设置 Next 为 none。none是被定义在 boost::msm::front。
// Transition table struct transition_table:mpl::vector< // Start Event Next Action Guard // Self transition msmf::Row < State1, Event1, State1, Action1, msmf::none >, // Internal transition msmf::Row < State1, Event2, msmf::none, Action2, msmf::none > > {};为了实现内部转换有两种不同方式。一种是在状态机中利用正常转变表并设置其 Next 状态为 none。此方法得优势在于此转变与其它转变放在一起，增强了其易读性。
另一种方式是使用内部转变表，此表仅仅用于内部转变。该方法允许我们重用内部转变和状态重用。另外内部状态转换表优先于正常状态转换表。
#include <iostream> #include <boost/msm/back/state_machine.hpp> #include <boost/msm/front/state_machine_def.hpp> #include <boost/msm/front/functor_row.hpp> namespace { namespace msm = boost::msm; namespace msmf = boost::msm::front; namespace mpl = boost::mpl; // Events struct Event1 {}; // ----- State machine struct Sm1_:msmf::state_machine_def<Sm1_> { struct State1_:msmf::state_machine_def<State1_> { // Guards struct InternalGuard1 { template <class Event, class Fsm, class SourceState, class TargetState> bool operator()(Event const&, Fsm&, SourceState&, TargetState&) const { std::cout << "Internal Transition Table's Guard1" << std::endl; return false; } }; struct InternalGuard2 { template <class Event, class Fsm, class SourceState, class TargetState> bool operator()(Event const&, Fsm&, SourceState&, TargetState&) const { std::cout << "Internal Transition Table's Guard2" << std::endl; return false; } }; // Internal Transition table struct internal_transition_table:mpl::vector< // Event Action Guard msmf::Internal < Event1, msmf::none, InternalGuard1 >, msmf::Internal < Event1, msmf::none, InternalGuard2 > > {}; }; // Set initial state typedef State1_ initial_state; // Guards struct Guard1 { template <class Event, class Fsm, class SourceState, class TargetState> bool operator()(Event const&, Fsm&, SourceState&, TargetState&) const { std::cout << "Transition Table's Guard1" << std::endl; return false; } }; struct Guard2 { template <class Event, class Fsm, class SourceState, class TargetState> bool operator()(Event const&, Fsm&, SourceState&, TargetState&) const { std::cout << "Transition Table's Guard2" << std::endl; return false; } }; // Transition table struct transition_table:mpl::vector< // Start Event Next Action Guard msmf::Row < State1_, Event1, msmf::none, msmf::none, Guard1 >, msmf::Row < State1_, Event1, msmf::none, msmf::none, Guard2 > > {}; }; // back-end typedef msm::back::state_machine<Sm1_> Sm1; void test() { Sm1 sm1; sm1.start(); std::cout << "> Send Event1" << std::endl; sm1.process_event(Event1()); } } int main() { test(); return 0; } // Output: // // > Send Event1 // Internal Transition Table's Guard2 // Internal Transition Table's Guard1 // Transition Table's Guard2 // Transition Table's Guard1Boost.Msm 不能直接支持连接点伪状态。如果想实现连接点伪状态，必须要转变 UML 模型。此转变过程十分简单。从于连接点伪状态相关的转变中分离每个独立的转变。 例如，关于如下图表： 它可以被转换为以下图表：
#include <iostream> #include <boost/msm/back/state_machine.hpp> #include <boost/msm/front/state_machine_def.hpp> #include <boost/msm/front/functor_row.hpp> namespace { namespace msm = boost::msm; namespace msmf = boost::msm::front; namespace mpl = boost::mpl; // Events struct Event1 { Event1(int val):val(val) {} int val; }; // ----- State machine struct Sm1_:msmf::state_machine_def<Sm1_> { struct State1_:msmf::state_machine_def<State1_>{}; // Set initial state typedef State1_ initial_state; // Guards struct Guard1 { template <class Event, class Fsm, class SourceState, class TargetState> bool operator()(Event const& e, Fsm&, SourceState&, TargetState&) const { if (e.val == 1) return true; return false; } }; struct Guard2 { template <class Event, class Fsm, class SourceState, class TargetState> bool operator()(Event const& e, Fsm&, SourceState&, TargetState&) const { if (e.val == 2) return true; return false; } }; // Actions struct Action1 { template <class Event, class Fsm, class SourceState, class TargetState> void operator()(Event const&, Fsm&, SourceState&, TargetState&) const { std::cout << "Action1" << std::endl; } }; struct Action2 { template <class Event, class Fsm, class SourceState, class TargetState> void operator()(Event const&, Fsm&, SourceState&, TargetState&) const { std::cout << "Action2" << std::endl; } }; // Transition table struct transition_table:mpl::vector< // Start Event Next Action Guard msmf::Row < State1_, Event1, State1_, Action1, Guard1 >, msmf::Row < State1_, Event1, State1_, Action2, Guard2 > > {}; }; // back-end typedef msm::back::state_machine<Sm1_> Sm1; void test() { Sm1 sm1; sm1.start(); std::cout << "> Send Event1(1)" << std::endl; sm1.process_event(Event1(1)); std::cout << "> Send Event1(2)" << std::endl; sm1.process_event(Event1(2)); } } int main() { test(); return 0; } // Output: // // > Send Event1(1) // Action1 // > Send Event1(2) // Action2有时可能需要用 if/else分支。考虑如下图表： Boost.Msm 不能直接支持 if/else 分支。如早些时候所提到，转变表和内部转变表是最低行到最高行逐步评估。这意味着你可以通过状态转变行在转变组中的位置来实现 if/else 分支。在else行的 guard 是 none。如下的状态转变表：
// Transition table struct transition_table:mpl::vector< // Start Event Next Action Guard msmf::Row < State1_, Event1, State1_, Action2, msmf::none >, // else msmf::Row < State1_, Event1, State1_, Action1, Guard1 > > {};首先，考虑下连接点伪状态和选择伪状态的不同。 这两个图表很相似。其唯一的差别在于一个用连接伪状态，另一个用选择伪状态。先来看图1，当 Event1 发生时，根据状态表中顺序选择首先执行哪个分支，且守卫条件的评估应该优先于Event1的动作调用，随后根据守卫条件的评估结果来决定是否调用对应分支的Event1的动作调用与否。若val = 1，则两个分支都的动作根据转换表中的顺序进行先后调用。(注意:与上一节中if/else分支的选择类似在val != 1是方能达到二者选其一的效果。)
然后，来看图2中的选择伪状态。当 Event1 发生时，在 Event1/val=1 的相应动作调用后将评估守卫条件。因此 val==1 分支被选择，随后 Val1Action 被调用。这意味着当此状态转换完成(转换到choice状态)后，相应的转换动作将被一个一个被评估是否进行条用。
接下来，看看选择伪状态在 Boost.Msm 中如何实现。Boost.Msm 不直接支持选择伪状态，但是可以用正常状态替代选择伪状态。替换后如下图表中所描述。
以下是对上述状态转换图表的具体代码实现：
#include <iostream> #include <boost/msm/back/state_machine.hpp> #include <boost/msm/front/state_machine_def.hpp> #include <boost/msm/front/functor_row.hpp> namespace { namespace msm = boost::msm; namespace msmf = boost::msm::front; namespace mpl = boost::mpl; // Events struct Event1 {}; // ----- State machine struct Sm1_:msmf::state_machine_def<Sm1_> { struct State1_:msmf::state<>{ template <class Event, class Fsm, class SourceState, class TargetState> void operator()(Event const&, Fsm& f, SourceState&, TargetState&) const { f.val = 0; std::cout << "val = " << f.val << std::endl; } }; struct Choice_:msmf::state<>{}; // Set initial state typedef State1_ initial_state; // Guards struct GuardVal1 { template <class Event, class Fsm, class SourceState, class TargetState> bool operator()(Event const&, Fsm& f, SourceState&, TargetState&) const { if (f.val == 1) return true; return false; } }; // Actions struct ActionVal1Assign { template <class Event, class Fsm, class SourceState, class TargetState> void operator()(Event const&, Fsm& f, SourceState&, TargetState&) const { f.val = 1; std::cout << "ActionVal1Assign val = " << f.val << std::endl; } }; struct ActionVal1Branch { template <class Event, class Fsm, class SourceState, class TargetState> void operator()(Event const&, Fsm& f, SourceState&, TargetState&) const { std::cout << "ActionVal1Branch val = " << f.val << std::endl; } }; struct ActionElseBranch { template <class Event, class Fsm, class SourceState, class TargetState> void operator()(Event const&, Fsm& f, SourceState&, TargetState&) const { std::cout << "ActionElseBranch val = " << f.val << std::endl; } }; // Transition table struct transition_table:mpl::vector< // Start Event Next Action Guard msmf::Row < State1_, Event1, Choice_, ActionVal1Assign, msmf::none >, msmf::Row < Choice_, msmf::none, State1_, ActionElseBranch, msmf::none >, // else msmf::Row < Choice_, msmf::none, State1_, ActionVal1Branch, GuardVal1 > > {}; private: int val; }; // back-end typedef msm::back::state_machine<Sm1_> Sm1; void test() { Sm1 sm1; sm1.start(); std::cout << "> Send Event1" << std::endl; sm1.process_event(Event1()); } } int main() { test(); return 0; } // Output: // // > Send Event1 // ActionVal1Assign val = 1 // ActionVal1Branch val = 1TODO.
参考链接： https://www.jianshu.com/p/6748aa7c117b
