【附】深入理解C++ 状态模式(C++实现源码)
<上一节
下一节>
对于状态模式,很多情况下和策略模式看起来极为相似。实际上它们都是为了解决具体子类实现抽象接口的实现异构问题而存在的(封装变化),但是它们的侧重各不相同。而针对算法的异构问题,模板方法模式通过继承的方式来改变一部分算法实现(原子操作在不同具体子类中可以有不同实现),策略模式则通过组合的方式来改变整个算法(可动态替换),而状态模式则强调的是针对不同的状态对象可以有不同的响应。因此状态模式实际上强调的状态的概念,并且强调对状态转换的逻辑封装,即对象可能处于不同的状态下,而各个状态在响应了该状态的实现后可能会动态转到另一个状态,而这个转变我们不希望 Context 的参与(Context 不必维护这个转换)。状态机在编译原理的 DFA/NDFA 中很常见,针对一个输入字符和已有串,DFA/NDFA 可能会转换到另外一个状态。
因此对于状态模式有以下几个关键点:
以下就按照上面的解释给出一个 C++的源码实现,首先给出其结构图:
C++实现源码为:
//context.h
#ifndef _CONTEXT_H_
#define _CONTEXT_H_
class State;
/**
*
**/
class Context{
public:
Context();
Context(State* state);
~Context();
void Handle();
void OperationForStateA();
void OperationForStateB();
protected:
private:
friend class State; //表明在 State 类中可以访问
Context 类的 private 字段,重要是访问 ChangeState
void ChangeState(State* state);
private:
State* _state;
};
#endif //~_CONTEXT_H_
//context.cpp
#include "Context.h"
#include "State.h"
#include <iostream>
using namespace std;
Context::Context(){
}
Context::Context(State* state){
this->_state = state;
}
Context::~Context(){
delete _state;
}
void Context::Handle(){
_state->Handle(this);
}
void Context::ChangeState(State* state){
///_state->ChangeState(this,state);
this->_state = state;
}
void Context::OperationForStateA(){
cout<<"Do operation in State A ";
}
void Context::OperationForStateB(){
cout<<"Do operation in State B ";
}
//state.h
#ifndef _STATE_H_
#define _STATE_H_
class Context; //前置声明
class State{
public:
State();
virtual ~State();
virtual void Handle(Context* con) = 0;
protected:
void ChangeState(Context* con,State* st);
private:
//bool ChangeState(Context* con,State* st);
};
class ConcreteStateA:public State{
public:
ConcreteStateA();
virtual ~ConcreteStateA();
void Handle(Context* con);
protected:
private:
};
class ConcreteStateB:public State{
public:
ConcreteStateB();
virtual ~ConcreteStateB();
void Handle(Context* con);
protected:
private:
};
#endif //~_STATE_H_
//State.cpp
#include "State.h"
#include "Context.h"
#include <iostream>
using namespace std;
State::State(){
}
State::~State(){
}
void State::ChangeState(Context* con,State* st){
con->ChangeState(st);
}
///
ConcreteStateA::ConcreteStateA(){
}
ConcreteStateA::~ConcreteStateA(){
}
void ConcreteStateA::Handle(Context* con){
con->OperationForStateA();
cout<<":: State change from A to B"<<endl;
State::ChangeState(con,new ConcreteStateB());
}
///
ConcreteStateB::ConcreteStateB(){
}
ConcreteStateB::~ConcreteStateB(){
}
void ConcreteStateB::Handle(Context* con){
con->OperationForStateB();
cout<<":: State change from B to A"<<endl;
State::ChangeState(con,new ConcreteStateA());
}
//main.cpp
#include "Context.h"
#include "State.h"
#include <iostream>
using namespace std;
int main(int argc,char* argv[]){
State* st = new ConcreteStateA();
Context* con = new Context(st);
con->Handle();
con->Handle();
con->Handle();
if (con != NULL)
delete con;
if (st != NULL)
st = NULL;
return 0;
}
可以看到在测试程序中,三次调用 con->Handle(),因为 con 状态的不同,可以得到以下的输出:
Do operation in State A :: State change from A to B
Do operation in State B :: State change from B to A
Do operation in State A :: State change from A to B
而 con 对于状态的转变一无所知,并且针对不同的状态有了不同的处理。
因此对于状态模式有以下几个关键点:
- 状态模式会处理算法的不同,但是更加关注的是状态的改变。并且对于状态的转变逻辑一般会放在 State 子类中实现。而对于不同状态的处理则可以放在 Context 类中,State 子类保存一个指向 Context 的引用(实际上往往传递一个指向 Context 的指针即可,而不必在 State 子类真正保存一个引用),以调用这些实现。当然放在 State 子类中实现也无可厚非,不过为了突出重点,使用前一种方式实现更能说明问题。当然在实际开发中,完全可以不受这个制约。
- 在具体实现过程中,对状态的改变我们会在 Context 类中实现(因为Context 才有 State 的概念),而在 State 子类中的状态转变逻辑实现则通过调用这个实现来达到目的。当然为了不让这个改变状态的接口暴露给普通客户程序员,我们将 Context 中这个接口声明为 private,而在将State 类声明为 Context 的 friend 类,并且将 State 子类中状态改变逻辑实现声明为 Protected,不让普通客户程序员调用。具体请参考示例代码部分。
以下就按照上面的解释给出一个 C++的源码实现,首先给出其结构图:
C++实现源码为:
//context.h
#ifndef _CONTEXT_H_
#define _CONTEXT_H_
class State;
/**
*
**/
class Context{
public:
Context();
Context(State* state);
~Context();
void Handle();
void OperationForStateA();
void OperationForStateB();
protected:
private:
friend class State; //表明在 State 类中可以访问
Context 类的 private 字段,重要是访问 ChangeState
void ChangeState(State* state);
private:
State* _state;
};
#endif //~_CONTEXT_H_
//context.cpp
#include "Context.h"
#include "State.h"
#include <iostream>
using namespace std;
Context::Context(){
}
Context::Context(State* state){
this->_state = state;
}
Context::~Context(){
delete _state;
}
void Context::Handle(){
_state->Handle(this);
}
void Context::ChangeState(State* state){
///_state->ChangeState(this,state);
this->_state = state;
}
void Context::OperationForStateA(){
cout<<"Do operation in State A ";
}
void Context::OperationForStateB(){
cout<<"Do operation in State B ";
}
//state.h
#ifndef _STATE_H_
#define _STATE_H_
class Context; //前置声明
class State{
public:
State();
virtual ~State();
virtual void Handle(Context* con) = 0;
protected:
void ChangeState(Context* con,State* st);
private:
//bool ChangeState(Context* con,State* st);
};
class ConcreteStateA:public State{
public:
ConcreteStateA();
virtual ~ConcreteStateA();
void Handle(Context* con);
protected:
private:
};
class ConcreteStateB:public State{
public:
ConcreteStateB();
virtual ~ConcreteStateB();
void Handle(Context* con);
protected:
private:
};
#endif //~_STATE_H_
//State.cpp
#include "State.h"
#include "Context.h"
#include <iostream>
using namespace std;
State::State(){
}
State::~State(){
}
void State::ChangeState(Context* con,State* st){
con->ChangeState(st);
}
///
ConcreteStateA::ConcreteStateA(){
}
ConcreteStateA::~ConcreteStateA(){
}
void ConcreteStateA::Handle(Context* con){
con->OperationForStateA();
cout<<":: State change from A to B"<<endl;
State::ChangeState(con,new ConcreteStateB());
}
///
ConcreteStateB::ConcreteStateB(){
}
ConcreteStateB::~ConcreteStateB(){
}
void ConcreteStateB::Handle(Context* con){
con->OperationForStateB();
cout<<":: State change from B to A"<<endl;
State::ChangeState(con,new ConcreteStateA());
}
//main.cpp
#include "Context.h"
#include "State.h"
#include <iostream>
using namespace std;
int main(int argc,char* argv[]){
State* st = new ConcreteStateA();
Context* con = new Context(st);
con->Handle();
con->Handle();
con->Handle();
if (con != NULL)
delete con;
if (st != NULL)
st = NULL;
return 0;
}
可以看到在测试程序中,三次调用 con->Handle(),因为 con 状态的不同,可以得到以下的输出:
Do operation in State A :: State change from A to B
Do operation in State B :: State change from B to A
Do operation in State A :: State change from A to B
而 con 对于状态的转变一无所知,并且针对不同的状态有了不同的处理。
<上一节
下一节>