设计模式-状态模式的应用

     上次写过文章关于实时控制线程类，这次是将状态模式与实时控制线程类连接起来，作了一个周期性执行任务。并按到指定的状态，周期有序地执行指定的任务。

      本文主要讲解下状态模式的实现方法，首先对状态模式作下简单的定义：允许一个对象在其内部状态改变时改变它的行为，对象看起来似乎修改了它的类。接下来我们以一个普通的状态类来描述执行的过程，一个普通的任务分为三个状态：空闲、运行、结束。随着任务的进度执行，由状态的变化过程状态依次为空闲->运行->结束。

由MachineProcess和CMachineState组成，关系图如下：

接下来主要讲解下流程控制类MachineProcess和子状态类MachineState基本使用方法。

CMachineProcess类

1.属于任务基类，可自由添加任务的多个子状态CMachineState类，以链表方法子状态类按顺序执行（也可根据实际情况在NextState()方法上作不同状态间的切换）。

2. 由控制线程按照指定的周期有序的调度MachineProcess任务类的Exectue（）方法成功有序完成不同状态执行。

CMachineState类

1.属于状态类的基类，子状态根据实现具体的方法Work()。

2.任务类主动调用 Execute()方法进行子状态具体动作的实现，并完成子状态动作后由MachineProcessr方法NextState()切换到下一个状态。

代码如下：

MachineProcess.h

#include <list>
using namespace std;

#pragma once

class CMachineState;
typedef CMachineState* MachineState_p;
class CMachineProcess;
typedef CMachineProcess* MachineProcess_p;
///////////////////////////////////////////////////
typedef enum ProcessState
{
	IDLE,
	RUN,
	FINISH
}ProcessState_t;
////////////////////////////////////////////////////
class CMachineProcess
{
public:
	CMachineProcess();
	virtual ~CMachineProcess();

	virtual void NextState();

	void Start();
	void Execute();

	bool IsFinish();
protected:
	list<MachineState_p> m_StateList;

	ProcessState_t m_ProcessState;
	MachineState_p  m_pMachineState;
private:
	
};

/////////////////////////////////////////////////
class CMachineState
{
public:
	CMachineState();
	virtual ~CMachineState();

	void Execute(MachineProcess_p pProcess);
protected:
	virtual void Work();

};

/////////////////////////////////////////////////

MachineProcess.cpp

#include "MachineProcess.h"

/////////////////////////////////////////////////
CMachineProcess::CMachineProcess()
{
	m_ProcessState = IDLE;
	m_pMachineState = NULL;
}


CMachineProcess::~CMachineProcess()
{
	if (m_pMachineState != NULL)
	{
		delete m_pMachineState;
	}
}

void CMachineProcess::NextState()
{
	
	if (!m_StateList.empty())
	{
		if (m_pMachineState != NULL)
		{
			delete m_pMachineState;
		}
		m_pMachineState = m_StateList.front();
		m_StateList.pop_front();
	}
	else
	{
		m_ProcessState = FINISH;
	}

}

bool CMachineProcess::IsFinish()
{
	return m_ProcessState == FINISH;
}

void CMachineProcess::Start()
{
	m_ProcessState = RUN;
	m_pMachineState = m_StateList.front();
	m_StateList.pop_front();
}

void CMachineProcess::Execute()
{
	if (m_ProcessState == IDLE)
	{
		return;
	}

	if (m_ProcessState == RUN)
	{
		m_pMachineState->Execute(this);
	}
	else
	{

	}
}

///////////////////////////////////////////////
CMachineState::CMachineState()
{
}


CMachineState::~CMachineState()
{
}
void CMachineState::Work()
{

}

void CMachineState::Execute(MachineProcess_p pProcess)
{
	Work();
	pProcess->NextState();
}

以上两类为任务执行基类和任务状态基类。

具体的实现类介绍

1. 任务控制类

代码实现是任务共有三种状态，依次顺序执行，直到任务全部执行完成。

#pragma once
#include "MachineProcess.h"
//////////////////////////////////////////////////

class CWorkProcess :
	public CMachineProcess
{
public:
	CWorkProcess();
	virtual ~CWorkProcess();
};

/////////////////////////////////////////////////
#include "WorkProcess.h"
#include "IdleState.h"
#include "RunState.h"
#include "FinishState.h"

CWorkProcess::CWorkProcess()
{
	m_StateList.push_back(new CIdleState());   //空闲状态
	m_StateList.push_back(new CRunState());    //运行状态
	m_StateList.push_back(new CFinishState()); //结束状态
}


CWorkProcess::~CWorkProcess()
{
}
///////////////////////////////////////////////////

2. 具体状态类

代码实现具体状态类：空闲状态、运行状态和结束状态。

2.1 空闲状态

#pragma once
#include "MachineProcess.h"
class CIdleState :
	public CMachineState
{
public:
	CIdleState();
	virtual ~CIdleState();

	void Work();
};
/////////////////////////////////////////////////////////////
#include "IdleState.h"
#include <iostream>

CIdleState::CIdleState()
{
}


CIdleState::~CIdleState()
{
}

void CIdleState::Work()
{
	std::cout << "this is idle state!" << endl;
}
///////////////////////////////////////////////////////////

2.2 运行状态

#pragma once
#include "MachineProcess.h"
class CRunState :
	public CMachineState
{
public:
	CRunState();
	virtual ~CRunState();

	void Work();
};

//////////////////////////////////////////////////////////////
#include "RunState.h"
#include <iostream>

CRunState::CRunState()
{
}


CRunState::~CRunState()
{
}

void CRunState::Work()
{
	std::cout << "this is run state!" << endl;
}
//////////////////////////////////////////////////////////////

2.3 结束状态

#pragma once
#include "MachineProcess.h"
class CFinishState :
	public CMachineState
{
public:
	CFinishState();
	virtual ~CFinishState();

	void Work();
};

//////////////////////////////////////////////////////////////
#include "FinishState.h"
#include <iostream>

CFinishState::CFinishState()
{
}


CFinishState::~CFinishState()
{
}

void CFinishState::Work()
{
	std::cout << "this is finish state!" << endl;
}
/////////////////////////////////////////////////////////////