【重读设计模式】状态模式

状态模式主要解决的是当控制一个对象状态的条件表达式过于复杂时的情况。把状态的判断逻辑转移到表示不同状态的一系列类中，可以把复杂的判断逻辑简化。

适用场景：

1.一个对象的行为取决于它的状态，并且它必须在运行时刻根据状态改变它的行为。

2.一个操作中含有庞大的多 分支结构，并且这些分支决定于对象的状态。

例子：一般的大系统都有任务系统，比如定时任务。任务有停止、启动、暂停、完成几种状态，而任务会发生状态改变是因行为导致，比如一个任务手动将其启动或者暂停甚至于完成。

类图：

类实现：

//任务类本身
class CTask
{
public: 
CTask():init_state_(NULL),running_state_(NULL),pause_state_(NULL),stop_state_(NULL),curr_state_(NULL)
{
init_state_ = new CInitState(this);
running_state_ = new CRuinningState(this);
pause_state_ = new CPauseState(this);
stop_state_ = new CStopState(this);

//默认的状态是初始状态
curr_state_ = init_state_;
}

//对任务的动作，每个动作都是一个函数，如果按照传统的设计

//用户手动启动一个任务
int start()
{
return curr_state_->start();
}

int stop()
{
return curr_state_->stop();
}

int pause()
{
return curr_state_->pause();
}

int finish()
{
return curr_state_->finish();
}

//设置该任务的状态,注意这里，new_state是一个指针，则替换状态只需要替换指针即可
int set_state(CState* new_state)
{
curr_state_ = new_state;
}

//下面是获取各种状态的实例函数
CState* getInitState()
{
return init_state_;
}
CState* getRunningState()
{
return running_state_;
}
CState* getPauseState()
{
return pause_state_;
}
CState* getStopState()
{
return stop_state_;
}
private:
//任务有下面的几个成员，因为任务有可能是下面的几种状态
CState* init_state_;
CState* running_state_;
CState* pause_state_;
CState* stop_state_;

//任务的当前状态
CState* curr_state_;
}


//状态类，纯抽象类，子类必须实现所有的函数
class CState
{
public:
int start() = 0;
int stop() = 0;
int pause() = 0;
int finish() = 0;
}


//初始状态类
class CInitState : public CState
{
public:
CInitState(CTask* task)
{
task_ = task;
}

//对于初始化的任务来说，下面的动作（也就是函数）的行为是可预计的

//对于初始化任务，是可以有开始操作的
int start()
{
//提示用户可以启动任务，并且将任务状态置为运行中
printf("您启动了任务，该任务当前状态为运行中\n");
task_->set_state(task_->getRunningState());
return 0;
}

int stop()
{
printf("初始状态的任务不支持停止操作\n");
return 0;
}

int pause()
{
printf("初始状态不支持暂停操作\n");
return 0;
}

int finish()
{
printf("您结束了该任务，该任务当前状态为结束\n");
return 0;
}

private:
CTask* task_;
}


//正在运行态
class CRunningState : public CState
{
public:
CRunningState(CTask* task)
{
task_ = task;
}

int start()
{
printf("正在运行中的任务不能再次启动\n");
return 0;
}

int stop()
{
printf("您停止了该任务，该任务当前状态为停止\n");
task_->set_state(task_->getStopState());
return 0；
}

int pause()
{
printf("您暂停了该任务，该任务当前状态为暂停\n");
task_->set_state(task_->getPauseState());
return 0;
}

int finish()
{
printf("正在运行的任务不能被完成\n");
return 0;
}

private:
CTask* task_;
}


//暂停状态
class CPauseState : public CState
{
public:
CPauseState(CTask* task)
{
task_ = task;
}
int start()
{
printf("重启任务成功，该任务当前状态为启动\n");
task_->set_state(task_->getPauseState());
return 0;
}

int stop()
{
printf("停止任务成功，该任务当前状态为停止\n");
task_->set_state(task_->getStopState());
return 0;
}

int pause()
{
printf("处于暂停状态的任务不支持暂停\n");
return 0;
}

int finish()
{
printf("处于暂停状态的任务不支持完成\n");
return 0;
}

private:
CTask* task_;
}


//停止状态
class CStopState : public CState
{
public:
CStopState(CTask* task)
{
task_ = task;
}

int start()
{
printf("处于停止状态的任务不支持启动\n");
return 0;
}

int stop()
{
printf("处于停止状态的任务不支持停止\n");
return 0;
}

int pause()
{
printf("处于停止状态的任务不支持暂停\n");
return 0;
}

int finish()
{
printf("处于停止状态的任务不支持完成\n");
return 0;
}

private:
CTask* task_;
}


class CFinishState : public CState
{
public:
CFinishState(CTask* task)
{
task_ = task;
}

int start()
{
printf("处于完成状态的任务不支持启动\n");
return 0;
}

int stop()
{
printf("处于完成状态的任务不支持停止\n");
return 0;
}

int pause()
{
printf("处于完成状态的任务不支持暂停\n");
return 0;
}

int finish()
{
printf("处于完成状态的任务不支持完成\n");
return 0;
}

private:
CTask* task_;
}


//主函数
void main()
{
//建立一个任务
CTask task;

//启动该任务
task.start();

//暂停该任务
task.pause();

//再启动该任务
task.state();

//停止该任务
task.stop();

return 0;
}

再回头看下状态模式有什么好处，对于普通的面向过程编码方式，应该是这样的：

if(curr_state==STATE_INIT)

{

if(operator == OPER_RUNNING)

{

XXXXX;

}

else if( operator == OPER_PAUSE)

{

xxxx;

}