设计模式之状态模式，C++实现

代码：

这次代码质量不佳啊，估计是应用场景选择错误了。

// StateMode.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include <string>

#ifdef _DEBUG
#define _CRTDBG_MAP_ALLOC
#include <stdlib.h>
#include <crtdbg.h>
#define new new(_NORMAL_BLOCK, __FILE__, __LINE__)
#endif

inline void EnableMemLeakCheck()
{
_CrtSetDbgFlag(_CrtSetDbgFlag(_CRTDBG_REPORT_FLAG) | _CRTDBG_LEAK_CHECK_DF);
}
// 状态模式（State）， 当一个对象的内在状态改变时允许改变其行为，这个对象看起来像是改变了其类

// 惨不忍睹的程序，几乎没有产生的必要，算作是记录吧
// 有可能是应用场景错了吧，貌似没有什么用处

// 根据作业流程的顺序，连环创建指针，没有太长的分支判断语句
// 不过如果作业流程顺序不确定，或者有偏差，会有重复的new
// 如果流程顺序有跳跃，会顺序转到该顺序执行
// 而且如此频繁的new和delete对于实时渲染来说，确实不好

// 假设一个数据从加载到显示有这么些状态
enum E_State
{
WAITING_LOAD, // 等待加载
LOADED, // 加载完成
SHOWING, // 正在显示
SHOWED, // 显示完成
ERROR // 在某一步中发生错误了
};

class Context;

// 各种状态的基类，实现了各种操作
class State
{
public:
virtual ~State()
{
;
}
virtual void Handle(Context *pCt) = 0;
};

// 待渲染的模型
class Model
{
public:
std::string m_strDescription;
protected:
private:
};
class LoadData;
class BuildDataRenderObject;
class ShowData;

// Context作为上下文，包括了状态子类的指针，并存储了当前状态,以及物体的信息
class Context
{
public:
Context();
~Context();

void SetState(State *pSt)
{
m_pSt = pSt;
}
void Request();

void ReleaseStatePtr();
State *m_pSt;
E_State m_eState;
Model m_Model;
};

// 渲染体创建完之后会显示数据
class ShowData : public State
{
public:
void Handle(Context *pCt)
{
if (SHOWING == pCt->m_eState)
{
printf("Start a new thread to Show data!\n");
}
else
{
pCt->ReleaseStatePtr();
printf("A frame End!\n");
}
}
};

// 加载完数据后会创建数据的渲染体
class BuildDataRenderObject : public State
{
public:
void Handle(Context *pCt)
{
if (LOADED == pCt->m_eState)
{
printf("Start a new thread to Build RenderObject of item!\n");
}
else
{
pCt->ReleaseStatePtr();
pCt->SetState(new ShowData);
pCt->Request();
}
}
};

// 程序开始的时候会加载数据
class LoadData : public State
{
public:
void Handle(Context *pCt)
{
if (WAITING_LOAD == pCt->m_eState)
{
printf("Start a new thread to Parse file and loading data!\n");
}
else
{
pCt->ReleaseStatePtr();
pCt->SetState(new BuildDataRenderObject);
pCt->Request();

}
}
};

Context::Context()
{
m_pSt = new LoadData;
m_Model.m_strDescription = "A New Model ,need to loaded";
}

Context::~Context()
{
ReleaseStatePtr();
}

void Context::ReleaseStatePtr()
{
if (m_pSt)
{
delete m_pSt;
m_pSt = NULL;
}
}

void Context::Request()
{
if (!m_pSt)
{
m_pSt = new LoadData;
}
m_pSt->Handle(this);
}

int _tmain(int argc, _TCHAR* argv[])
{
EnableMemLeakCheck();
Context *pCtxt = new Context();

// 不同状态（流程顺序）的数据进行处理

printf("\nstate is waiting load:\n");
pCtxt->m_eState = WAITING_LOAD;
pCtxt->m_Model.m_strDescription = "Loaded";
pCtxt->Request();

printf("\nstate is loaded:\n");
pCtxt->m_eState = SHOWED;
pCtxt->m_Model.m_strDescription = "...";
pCtxt->Request();

if (pCtxt)
{
delete pCtxt;
pCtxt = NULL;
}

return 0;
}

// 输出结果：

//state is waiting load:
//Start a new thread to Parse file and loading data!
//
//state is loaded:
//A frame End!
//请按任意键继续. . .