先提一下昨天的思路：
- 电梯包含了四种状态：关门，开门，运动，停止
- 状态之间会进行转换：关门（默认）->开门->关门->运动->停止->开门->关门
所以，在代码实现时，就出现了一个［状态（枚举）］［电梯（类）］，其中［电梯］包含了四种状态的处理逻辑，以及提供了一个［去某一层］的方法。状态之间的转换直接写在状态的处理逻辑中（例如开门状态的处理，就是转换到关门状态）。
然后，以此为基础，再进行今天的状态机的学习。
经过一番查阅，我对状态机的理解有一些改变了：
从电梯的例子来看，电梯的运行过程包含了4个状态。如果我在电梯的gotoFloor函数中，使用
if (当前为关门状态) { 关门状态的处理;下一个状态; } else if (当前为开门状态) {开门状态的处理;下一个状态;} else if (当前为运行状态) {运行状态的处理;下一个状态;} ...
这样的方式来进行状态的处理与转换，这也是状态机的一种实现方式。
所以呢？状态机是什么？我的理解就是：状态机就是控制物体状态转换的逻辑，也就是上面这一堆
if () {} else if () {} ...。
为什么搜到的多数博客中都把状态机描述得很复杂呢？因为状态机本身就是一套状态转换逻辑，只不过它是为了处理更复杂的物体的状态转换而编写的。
所以状态机的运用，在于怎样合理、高效的实现状态的转换，把原本需要使用大量 if .. else if ..来处理的转换逻辑描述的更清晰。
好了，昨天写的转换看起来还比较清晰（一点也不高端，就是把if...else if...换成了swith...case...），但是如果需要扩展新状态，就要改动原来的swich...case...了。
所以今天换一种实现方式：为每个状态实现一个状态类。
详细设计：
- 状态类的基类
* 一个［执行逻辑处理］函数
* 一个［电梯］对象
* 一个［设置电梯］函数 - 关门［状态类］
* ... - 开门［状态类］
* ... - 运动［状态类］
* ... - 停止［状态类］
* ...
*电梯［类］
* 关门状态类［指针］
* 开门状态类［指针］
* 运动状态类［指针］
* 停止状态类［指针］
* 当前状态类［指针］
* 设置状态［函数］
* 按下电梯［函数］
源文件：
//
// ElevatorTwo.hpp
// QFLTest
//
// Created by QuFangliu on 16/9/19.
//
//
#ifndef ElevatorTwo_hpp
#define ElevatorTwo_hpp
#include <stdio.h>
//预先声明一下，在state中需要用到
class ElevatorTwo;
//Elevator has four status : closing, opening, running, stopping
//Four status correspond four classes. All of them inherited from one base state class.
class ElevatorStateBase
{
public:
virtual ~ElevatorStateBase() {}
//某个状态需要执行的逻辑
virtual void excute() = 0;
//设置电梯类
void setElevator(ElevatorTwo *pElevator) { m_pElevator = pElevator; }
protected:
//保存一个ElevatorTow的指针，为了修改它的状态
ElevatorTwo *m_pElevator;
};
//四种状态的类
//Closing
class ElevatorStateClosing : public ElevatorStateBase
{
public:
ElevatorStateClosing();
virtual ~ElevatorStateClosing();
//执行逻辑
virtual void excute() override;
};
//Opening
class ElevatorStateOpening : public ElevatorStateBase
{
public:
ElevatorStateOpening();
virtual ~ElevatorStateOpening();
//执行逻辑
virtual void excute() override;
};
//Running
class ElevatorStateRunning : public ElevatorStateBase
{
public:
ElevatorStateRunning();
virtual ~ElevatorStateRunning();
//执行逻辑
virtual void excute() override;
};
//Stopping
class ElevatorStateStopping : public ElevatorStateBase
{
public:
ElevatorStateStopping();
virtual ~ElevatorStateStopping();
//执行逻辑
virtual void excute() override;
};
//电梯类
class ElevatorTwo
{
public:
ElevatorTwo();
virtual ~ElevatorTwo();
//对外开放的操作
void gotoFloor();
public:
//每个状态都有一个class
ElevatorStateBase *m_pStateClosing = nullptr;
ElevatorStateBase *m_pStateOpening = nullptr;
ElevatorStateBase *m_pStateRunning = nullptr;
ElevatorStateBase *m_pStateStopping = nullptr;
//设置状态
void setState(ElevatorStateBase *pState) { m_pState = pState; pState->excute();}
private:
//当前状态
ElevatorStateBase *m_pState = m_pStateClosing; //默认关闭状态
};
#endif /* ElevatorTwo_hpp */
//
// ElevatorTwo.cpp
// QFLTest
//
// Created by QuFangliu on 16/9/19.
//
//
#include "ElevatorTwo.hpp"
#include <iostream>
#define QFLLOG(_text_) do \
{ \
std::cout << _text_ << std::endl; \
} while (false) \
//ElevatorStateBase不需要在这里写实现部分了，它是一个抽象类，不能实例化
//Closing
ElevatorStateClosing::ElevatorStateClosing()
{
m_pElevator = nullptr;
}
ElevatorStateClosing::~ElevatorStateClosing()
{
}
void ElevatorStateClosing::excute()
{
//Closing的逻辑部分
//关门之后，进行一些处理
QFLLOG("Closing->关上电梯门，等待有人按电梯");
//处理完成，根据条件判断下一状态
if (rand() % 100 > 50) {
//假设50%几率，电梯里面没有人（这里的关闭可能是之前一轮运行完后的关闭）
QFLLOG("Closing->没有要去的楼层,停在这个状态");
}
else {
//50%几率，有人选择了下一个楼层
QFLLOG("Closing->准备前往下一个目标楼层");
m_pElevator->setState(m_pElevator->m_pStateRunning);
}
}
//Opening
ElevatorStateOpening::ElevatorStateOpening()
{
m_pElevator = nullptr;
}
ElevatorStateOpening::~ElevatorStateOpening()
{
}
void ElevatorStateOpening::excute()
{
//Opening的逻辑部分
//开门之后，进行一些处理
QFLLOG("Opening->打开电梯门");
//处理完成，下一状态就是关门（转换到下一状态这件事，可以由某些条件触发）
QFLLOG("Opening->上客、下客完成，准备关门");
m_pElevator->setState(m_pElevator->m_pStateClosing);
}
//Running
ElevatorStateRunning::ElevatorStateRunning()
{
m_pElevator = nullptr;
}
ElevatorStateRunning::~ElevatorStateRunning()
{
}
void ElevatorStateRunning::excute()
{
//Running的逻辑部分
//运行到指定的楼层
QFLLOG("Running->运行前往指定的楼层（加速，匀速，减速）");
//处理完成，下一状态就是保持电梯停止（状态转换事件可以由条件触发）
QFLLOG("Running->到了指定楼层，准备停止");
m_pElevator->setState(m_pElevator->m_pStateStopping);
}
//Stopping
ElevatorStateStopping::ElevatorStateStopping()
{
m_pElevator = nullptr;
}
ElevatorStateStopping::~ElevatorStateStopping()
{
}
void ElevatorStateStopping::excute()
{
//Stopping的逻辑部分
//保持电梯停止
QFLLOG("Stopping->保持电梯停止（刹车，锁定）");
//处理完成，下一状态就是开门（状态转换可以根据轿箱内是否有人来进行条件触发）
QFLLOG("Stopping->电梯锁定到楼层，准备开门");
m_pElevator->setState(m_pElevator->m_pStateOpening);
}
//电梯类
ElevatorTwo::ElevatorTwo()
{
//初始化自己的几个状态
m_pStateClosing = new ElevatorStateClosing();
m_pStateOpening = new ElevatorStateOpening();
m_pStateRunning = new ElevatorStateRunning();
m_pStateStopping = new ElevatorStateStopping();
//状态类设置"控制"类
m_pStateClosing->setElevator(this);
m_pStateOpening->setElevator(this);
m_pStateRunning->setElevator(this);
m_pStateStopping->setElevator(this);
}
ElevatorTwo::~ElevatorTwo()
{
//注意，要清内存噢
delete m_pStateClosing;
delete m_pStateOpening;
delete m_pStateRunning;
delete m_pStateStopping;
}
void ElevatorTwo::gotoFloor()
{
//用户的操作，必定是上或者下，也就是从这个事件开始改变状态
//事件导致的状态就是开门
this->setState(m_pStateOpening);
}
测试代码：
//初始化电梯
auto pElevator = new ElevatorTwo();
//按电梯咯
pElevator->gotoFloor();
输出结果（因为用到了随机数，所以输出结果类似，但不唯一）：
Opening->打开电梯门
Opening->上客、下客完成，准备关门
Closing->关上电梯门，等待有人按电梯
Closing->准备前往下一个目标楼层
Running->运行前往指定的楼层（加速，匀速，减速）
Running->到了指定楼层，准备停止
Stopping->保持电梯停止（刹车，锁定）
Stopping->电梯锁定到楼层，准备开门
Opening->打开电梯门
Opening->上客、下客完成，准备关门
Closing->关上电梯门，等待有人按电梯
Closing->没有要去的楼层,停在这个状态
示例总结：
1.［电梯］类，其实不需要持有各个状态的指针，当需要转换到某个状态时，生成一个新的状态对象即可。
2.需要扩展状态时，例如［运行］状态的逻辑处理中可能需要新增一个［故障］状态，此时只需要新增一个［故障］状态类，然后在［运行］状态逻辑中，满足故障条件时转换到［故障］状态即可。
总结：
1.状态机，就是一套用于控制物体状态转换的逻辑。实现状态机控制的首要条件就是清楚的划分物体的状态。
2.状态机有各种各样的实现方式，实现时需要考虑到子新增状态。
