state设计模式--学习总结--state设计模式和策略设计模式的区别

意图：

允许一个对象在其内部状态改变时改变它的行为。对象看起来似乎修改了它的类。

 

 

适用坏境：

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）。