意图:
允许一个对象在其内部状态改变时改变它的行为。对象看起来似乎修改了它的类。
适用坏境:
1) 一个对象的行为取决于它的状态,并且它必须在运行时刻根据状态改变它的行为。
2) 一个操作中含有庞大的多分支的条件语句,且这些分支依赖于该对象的状态。这个状态通常用一个或多个枚举常量表示。通常, 有多个操作包含这一相同的条件结构。State模式将每一个条件分支放入一个独立的类中。这使得你可以根据对象自身的情况将对象的状态作为一个对象,这一对象可以不依赖于其他对象而独立变化。
结构:
实现:
State.h 文件
#pragma once
class Context;
class State
{
public:
State(void);
virtual~State(void);
virtualvoid OperationInterface(Context *con);
virtualvoid OperationChangeState(Context*con);
protected:
boolChangeState(Context*con,State*st);
};
class ConcreteStateA:public State
{
public:
ConcreteStateA();
virtual~ConcreteStateA();
virtualvoid OperationInterface(Context *con);
virtualvoid OperationChangeState(Context*con);
protected:
};
class ConcreteStateB:public State
{
public:
ConcreteStateB();
virtual~ConcreteStateB();
virtualvoid OperationInterface(Context *);
virtualvoid OperationChangeState(Context*);
protected:
};
State.cpp文件
#include "StdAfx.h"
#include "State.h"
#include "Context.h"
#include "iostream"
using namespace std;
State::State(void)
{
}
State::~State(void)
{
}
void State::OperationInterface(Context*con)
{
cout<<"state::"<<endl;
}
void State::OperationChangeState(Context*con)
{
}
bool State::ChangeState(Context*con,State*st)
{
con->ChangeState(st);
returntrue;
}
ConcreteStateA::ConcreteStateA()
{
}
ConcreteStateA::~ConcreteStateA()
{
}
void ConcreteStateA::OperationInterface(Context*con)
{
cout<<"concreteStateA::operation Interface........"<<endl;
}
void ConcreteStateA::OperationChangeState(Context*con)
{
OperationInterface(con);
this->ChangeState(con,new ConcreteStateB());
cout<<"change state to B"<<endl;
}
//
ConcreteStateB::ConcreteStateB()
{
}
ConcreteStateB::~ConcreteStateB()
{
}
void ConcreteStateB::OperationInterface(Context*con)
{
cout<<"concreteStateB::operation Interface........"<<endl;
}
void ConcreteStateB::OperationChangeState(Context*con)
{
OperationInterface(con);
this->ChangeState(con,new ConcreteStateA());
cout<<"change state to A"<<endl;
}
Context.h文件
#ifndef _STATE_H
#define _STATE_H
class State;
class Context
{
public:
Context(void);
Context(State *state);
voidOperationInterface();
voidOperationChangeState();
virtual~Context(void);
private:
friendclass State; //表明在State类中可以访问Context类的私有字段
bool ChangeState(State*state);
State*_state;
};
#endif
Context.cpp文件
#include "StdAfx.h"
#include "Context.h"
#include "State.h"
Context::Context(void)
{
}
Context::~Context(void)
{
if(_state!=NULL)
{
delete_state;
_state=NULL;
}
}
Context::Context(State *state)
{
this->_state=state;
}
void Context::OperationInterface()
{
_state->OperationInterface(this);
}
bool Context::ChangeState(State*state)
{
this->_state=state;
returntrue;
}
void Context::OperationChangeState()
{
_state->OperationChangeState(this);
}
主函数:
// StatePatten.cpp : 定义控制台应用程序的入口点。
//
#include "stdafx.h"
#include "State.h"
#include "Context.h"
#include <iostream>
using namespace std;
int _tmain(intargc, _TCHAR*argv[])
{
State*st=new ConcreteStateA();
Context*con=new Context(st);
con->OperationInterface();
con->OperationChangeState();
if (con!=NULL)
{
deletecon;
con=NULL;
}
if(st!=NULL)
{
deletest;
st=NULL;
}
return0;
}
代码说明:
State模式在实现中,有2个关键点:
(1) 将State声明为Context的友元类(friend class),其作用是让State模式访问Context的Protected接口ChangeState();
(2) State及其子类中的操作都将Context*传入作为参数,其主要目的是State类可以通过这个指针调用Context中的方法,这也是State模式和Strategy模式的区别;
State 模式和Strategy模式又很大程度上的相似:它们都有一个 Context 类,都是通过委托(组合)给一个具有多个派生类的多态基类实现 Context的算法逻辑。两者最大的差别就是State模式中派生类持有指向Context对象的引用, 并通过这个引用调用Context中的方法,但在 Strategy 模式中就没有这种情况。因此可以说一个 State 实例同样是 Strategy 模式的一个实例,反之却不成立。实际上 State 模式和 Strategy 模式的区别还在于它们所关注的点不尽相同:State 模式主要是要适应对象对于状态改变时的不同处理策略的实现,而 Strategy则主要是具体算法和实现接口的解耦(coupling)。