有限状态机的实现方式

前两天学习了状态机，我也自己敲了一个，这里我就记录下来自己怎么学习的。有限状态机其实就是在有限个状态下，可以进行管理。

这里我举了这样一个例子，比如一个人Bobo他每天要干的三件事是睡觉、写代码、吃饭。这样我们就可以来模拟出一套这样的机制来切换和管理这个状态。

这里我们先定义一个Bobo类

/************************************************************************/
/* 定义一个Bobo类                                                                     */
/************************************************************************/
#ifndef _BOBO_H_
#define _BOBO_H_
class BoboFSM;
class Bobo
{
public:
	Bobo(BoboFSM *fsm); //构造函数
	~Bobo();//析构函数
	void code();//编码
	void sleep();//睡觉
	void eate();//吃饭
	BoboFSM *getFSM();//获取状态机
private:
	//状态机对象
	BoboFSM *m_fsm;
};
#endif

这里面定义了它的几个action吃饭睡觉编码。

然后来看它的实现

#include "Bobo.h"
#include "BoboFSM.h"
#include <iostream>
using namespace std;

Bobo::Bobo(BoboFSM *fsm)
{
	m_fsm = fsm;
	fsm->setObject(this);
}
Bobo::~Bobo()
{

}
//codeing
void Bobo::code()
{
	cout<<" i am coding"<<endl;
}
void Bobo::eate()
{
	cout<<"i am eate"<<endl;
}
void Bobo::sleep()
{
	cout<<"i am sleep"<<endl;
}
BoboFSM* Bobo::getFSM()
{
	return m_fsm;
}

然后我们开始编写状态机类说白了状态机类就是用来记录和管理这些行为

#ifndef _BOBO_FSM_H_
#define _BOBO_FSM_H_
#include "Bobo.h"
#include "state.h"
class BoboFSM
{
public:
	~BoboFSM();//析构函数
	void exchageState(BaseState *nowstate);/* 改变状态*/
	void setObject(const Bobo *bobo);//设置状态机管理的对象
	static BoboFSM* getInstance();//获取状态机事例
	
private:
	BoboFSM(); //采用单例模式
	/* 存放当前状态**/
	BaseState *m_nowstate;
	/*波波对象*/
	const Bobo *m_bobo;
};
#endif

这里状态机类我采用了单例模式，这样主要是为了可以让它来管理不同的对象，我们只需要调用setobject就可以了。下面我们来看怎么实现的。

#include "BoboFSM.h"
#include <iostream>
using namespace std;
BoboFSM ::BoboFSM()
{

}
BoboFSM::~BoboFSM()
{
	if (m_bobo!=NULL)
	{
		delete m_bobo;
		m_nowstate = NULL;
	}
	if (m_nowstate!=NULL)
	{
		delete m_nowstate;
		m_nowstate = NULL;
	}
}
/*单例的实现获取状态机事例*/
 BoboFSM *BoboFSM::getInstance()
{
	static BoboFSM fsm;
	return &fsm;
}
/*状态机改变状态*/
void BoboFSM::exchageState(BaseState *nowstate)
{
	if (m_nowstate != NULL)
	{
		delete m_nowstate;
		m_nowstate=NULL;//这是一个好习惯
	}
	m_nowstate = nowstate;
}
//设置状态机管理的对象
void BoboFSM::setObject( const Bobo *bobo)
{
	if (m_bobo != NULL)
	{
		delete m_bobo;
		m_bobo = NULL;
	}
	m_bobo = bobo;
}

最后就是编写我们的状态类了。首先我们编写一个基类。然后是吃饭，编码，睡觉状态。

#ifndef _STATE_H_
#define  _STATE_H_
class Bobo;
/*
状态基础类
*/
class BaseState
{
public:
	virtual void executeState(Bobo *b)=0; //执行状态
};
/* 吃饭状态 */
class Eate:public BaseState
{
public:
	void executeState(Bobo *b);//干吃饭的事情
};
/*编码*/
class Code:public BaseState
{
public:
	void executeState(Bobo *b);//编码状态
};
/*睡觉状态*/
class Sleep:public BaseState
{
public :
	void executeState(Bobo *b);
};
#endif

然后是这些状态的实现；

#include "Bobo.h"

#include "state.h"
void Eate::executeState(Bobo *b)
{
	b->eate();
}


void Code::executeState(Bobo *b)
{
	b->code();
}
void Sleep::executeState(Bobo *b)
{
	b->sleep();
}

最后我们来模拟一下事件和状态的改变。

#include "BoboFSM.h"
#include "Bobo.h"
#include "state.h"

int main()
{

	//得到状态机
	BoboFSM *fsm = BoboFSM::getInstance();
	//创建一个对象并且关联状态机
	Bobo *bobo = new Bobo(fsm);

	//模拟状态改变
	for(int i = 0 ; i <100 ; i ++)
	{
		printf("%d ",i);
		switch(i%3)
		{
		case 0:
			{
			
				Eate *e =new Eate();
				e->executeState(bobo);
				fsm->exchageState(e);
			}
			break;
		case 1:
			{
				Code *c =new Code();
				c->executeState(bobo);
				fsm->exchageState(c);
			}
			break;
		case 2:
			{
			Sleep *s =new Sleep();
			s->executeState(bobo);
			fsm->exchageState(s);
			}
			   break;
		}
		
	}
	
	fsm->setObject(NULL);	//删除bobo
	return 0;
}

然后我们就可以看到不停的在切换状态了。