设计模式：状态模式及有限状态机

有时候在组件构建的过程中，某些对象的状态经常面临变化，如何对变化进行有效管理的同时又能保证高层模块的稳定。（状态模式解决的问题）即是根据运行时的条件转换状态。
如果不用状态模式，普通开发可能会导致if-else增值过多以及破坏oop原则。
状态模式允许一个对象在内部状态改变它的行为，从而是对象看起来似乎修改了其行为。~GOF设计模式

state模式将所有的行为都放在state的子类对象中，在对象状态切换时，切换相应的对象。而且这样写可以使状态之间的转换更加明确，可以保证不出现状态不一致的情况，即有限状态机值可能处于其中某一种状态，转换是原子性的，要么彻底转换，要么不转换。

状态如果没有实例对象，那么各个上下文可以共享同一个静态对象，节省对象开销，及可以搭配singleton模式开发。

和策略模式挺像的，实际上如果状态只有一种行为的话，就是策略模式，实际就是策略模式加一个state_next指针指向下一个状态。
我们设计一个状态机

ps:其实虚函数在作用层面就是一个运行时的if-else.

#pragma once
#include <iostream>
using namespace std;
//状态基类，需要指针指向下一个状态（调用时）和具体的操作，所有的操作都要预先在状态基类虚定义
template<typename T>
class state_base {
public:
	state_base<T>* S_next;
	virtual state_base<T>* step1() = 0;
	virtual state_base<T>* step2() = 0;
	virtual state_base<T>* step3() = 0;
	void do_step1() {
		S_next = step1();
	}
	void do_step2() {
		S_next = step2();
	}
	void do_step3() {
		S_next = step3();
	}
	virtual void describe() {}
};

template<typename T>
class state0;
template<typename T>
class state1;
template<typename T>
class state2;
//state0
template<typename T>
class state0 :public state_base<T> {
public:
	static state0<T>* getInstance() {
		static state0<T>* m_instance_state0;
		if (m_instance_state0 == nullptr) {
			m_instance_state0 = new state0<T>;
		}
		return m_instance_state0;
	}

	virtual state_base<T>* step1() {
		return state1<T>::getInstance();
	}
	virtual state_base<T>* step2() {
		return state2<T>::getInstance();
	}
	virtual state_base<T>* step3() {
		return state0<T>::getInstance();
	}
	virtual void describe() {
		cout << "now in state0" << endl;
	}
private:
	state0() {};
};
//state1
template<typename T>
class state1 :public state_base<T> {
public:
	static state1<T>* getInstance() {
		static state1<T>* m_instance_state1;
		if (m_instance_state1 == nullptr) {
			m_instance_state1 = new state1<T>;
		}
		return m_instance_state1;
	}

	virtual state_base<T>* step1() {
		return state2<T>::getInstance();
	}
	virtual state_base<T>* step2() {
		return state0<T>::getInstance();
	}
	virtual state_base<T>* step3() {
		return state1<T>::getInstance();
	}
	virtual void describe() {
		cout << "now in state1" << endl;
	}
private:
	state1() {};
};
//state2
template<typename T>
class state2 :public state_base<T> {
public:
	static state2<T>* getInstance() {
		static state2<T>* m_instance_state2;
		if (m_instance_state2 == nullptr) {
			m_instance_state2 = new state2<T>;
		}
		return m_instance_state2;
	}

	virtual state_base<T>* step1() {
		return state0<T>::getInstance();
	}
	virtual state_base<T>* step2() {
		return state1<T>::getInstance();
	}
	virtual state_base<T>* step3() {
		return state2<T>::getInstance();
	}
	virtual void describe() {
		cout << "now in state2" << endl;
	}
private:
	state2() {};
};

//工作时候的流程
template<typename T>
class work_process {
protected:
	state_base<T>* now_state;
public:
	work_process(state_base<T>* start_state) :now_state(start_state) {}
	void process_step1() {
		now_state->do_step1();
		now_state = now_state->S_next;
		now_state->describe();
	}
	void process_step2() {
		now_state->do_step2();
		now_state = now_state->S_next;
		now_state->describe();
	}
	void process_step3() {
		now_state->do_step3();
		now_state = now_state->S_next;
		now_state->describe();
	}
};

测试接口

	cout << "测试状态模式 有限状态机" << endl;
	//好像首先需要把三个单例对象初始化nullptr
	//一开始构造函数没加{}，造成了LNK2019
	state0<bool>* start = state0<bool>::getInstance();
	auto working = new work_process<bool>(start);
	
	working->process_step1();//根据我画的状态机这三步后还是state0
	working->process_step1();
	working->process_step1();
	cout << endl;