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