State模式

State模式将状态逻辑和动作实现进行分离。当一个操作中要维护大量的case分支语句，并且这些分支依赖于对象的状态。State模式将每个分支都封装到独立的类中。

State.h

//state.h
#ifndef _STATE_H_
#define _STATE_H_

class Context; //前置声明
class State
{
public:
	State();
	virtual ~State();
	virtual void OperationInterface(Context* ) = 0;
	virtual void OperationChangeState(Context*) = 0;
protected:
	bool ChangeState(Context* con,State* st);
private:
//bool ChangeState(Context* con,State* st);
};

class ConcreteStateA:public State
{
public:
	ConcreteStateA();
	virtual ~ConcreteStateA();
	virtual void OperationInterface(Context* );
	virtual void OperationChangeState(Context*);
protected:
private:
};

class ConcreteStateB:public State
{
public:
	ConcreteStateB();
	virtual ~ConcreteStateB();
	virtual void OperationInterface(Context* );
	virtual void OperationChangeState(Context*);
protected:
private:
};
#endif //~_STATE_H_

State.cpp

//State.cpp
#include "State.h"
#include "Context.h"
#include <iostream>
using namespace std;

State::State()
{

}
State::~State()
{

}
void State::OperationInterface(Context* con)
{
	cout<<"State::.."<<endl;
}
bool State::ChangeState(Context* con,State* st)
{
	con->ChangeState(st);
	return true;
}
void State::OperationChangeState(Context* con)
{

}
ConcreteStateA::ConcreteStateA()
{

}
ConcreteStateA::~ConcreteStateA()
{

}
void ConcreteStateA::OperationInterface(Context* con)
{
	cout<<"ConcreteStateA::OperationInterface......"<<endl;
}
void ConcreteStateA::OperationChangeState(Context* con)
{
	OperationInterface(con);
	this->ChangeState(con,new ConcreteStateB());
}


ConcreteStateB::ConcreteStateB()
{

}
ConcreteStateB::~ConcreteStateB()
{

}
void ConcreteStateB::OperationInterface(Context* con)
{
	cout<<"ConcreteStateB::OperationInterface......"<<endl;
}
void ConcreteStateB::OperationChangeState(Context* con)
{
	OperationInterface(con);
	this->ChangeState(con,new ConcreteStateA());
}

Context.h

//context.h
#ifndef _CONTEXT_H_
#define _CONTEXT_H_
class State;

class Context
{
public:
	Context();
	Context(State* state);
	~Context();
	void OprationInterface();
	void OperationChangState();
protected:
private:
	friend class State; //表明在State类中可以访问Context类的private字段
	bool ChangeState(State* state);
private:
	State* _state;
};
#endif //~_CONTEXT_H_

Context.cpp

//context.cpp
#include "Context.h"
#include "State.h"

Context::Context()
{

}
Context::Context(State* state)
{
	this->_state= state;
}
Context::~Context()
{
	delete _state;
}

void Context::OprationInterface()
{
	_state->OperationInterface(this);
}
bool Context::ChangeState(State* state)
{
	this->_state= state;
	return true;
}
void Context::OperationChangState()
{
	_state->OperationChangeState(this);
}

State模式和Strategy模式有很大程度上的相似，实际上State模式和Strategy模式所关注的点不尽相同：State模式主要是适应对象对于状态改变时的不同处理策略的实现，而Strategy模式主要是具体算法和实现接口的解耦。