状态模式（C++实现）

（本博客旨在个人总结回顾）

1、详情：

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

说明：

主要解决：

对象的行为依赖于它的状态（属性），并且可以根据它的状态改变而改变它的相关行为。

优点：

①封装了转换规则。

②枚举可能的状态，在枚举状态之前需要确定状态种类。

③将所有与某个状态有关的行为放到一个类中，并且可以方便地增加新的状态，只需要改变对象状态即可改变对象的行为。

④允许状态转换逻辑与状态对象合成一体，而不是某一个巨大的条件语句块。

⑤可以让多个环境对象共享一个状态对象，从而减少系统中对象的个数。

缺点：

①状态模式的使用必然会增加系统类和对象的个数。

②状态模式的结构与实现都较为复杂，如果使用不当将导致程序结构和代码的混乱。

③状态模式对"开闭原则"的支持并不太好，对于可以切换状态的状态模式，增加新的状态类需要修改那些负责状态转换的源代码，否则无法切换到新增状态，而且修改某个状态类的行为也需修改对应类的源代码。

2.1、UML类图：

 

2.2、例子源码

stdafx.h

// stdafx.h : 标准系统包含文件的包含文件，
// 或是经常使用但不常更改的
// 特定于项目的包含文件
//

#pragma once

#include "targetver.h"

#include <stdio.h>
#include <tchar.h>

#include <iostream>
using namespace std;

// TODO:  在此处引用程序需要的其他头文件

State.h（状态接口类）

#pragma once
#include "Context.h"
class Context;

class State
{
public:
    State();
    virtual ~State();

public:
    virtual void Operation(Context* pContext) = 0;
    virtual string GetStateName() = 0;
};

State.cpp

#include "stdafx.h"
#include "State.h"

State::State()
{
}

State::~State()
{
}

StateX.h(具体状态类X)

#pragma once
#include "State.h"
class StateY;

class StateX :
    public State
{
public:
    StateX();
    ~StateX();

public:
    void Operation(Context* pContext);
    string GetStateName();
};

StateX.cpp

#include "stdafx.h"
#include "StateX.h"
#include "StateY.h"

StateX::StateX()
{
}

StateX::~StateX()
{
}

void StateX::Operation(Context* pContext)
{
    //操作时改变状态
    pContext->SetState(new StateY());
}

std::string StateX::GetStateName()
{
    return "StateX";
}

StateY.h(具体状态类Y)

#pragma once
#include "State.h"
class StateX;

class StateY :
    public State
{
public:
    StateY();
    ~StateY();

public:
    void Operation(Context* pContext);
    string GetStateName();
};

StateY.cpp

#include "stdafx.h"
#include "StateY.h"
#include "StateX.h"

StateY::StateY()
{
}

StateY::~StateY()
{
}

void StateY::Operation(Context* pContext)
{
    //操作时改变状态
    pContext->SetState(new StateX());
}

std::string StateY::GetStateName()
{
    return "StateY";
}

Context.h(上下文类)

#pragma once
#include "State.h"
class State;

class Context
{
public:
    Context(State* pState);
    ~Context();

public:
    void SetState(State* pState);
    State* GetState();
    void Request();

private:
    State* m_pState;
};

Context.cpp

#include "stdafx.h"
#include "Context.h"

Context::Context(State* pState)
    : m_pState(pState)
{
}

Context::~Context()
{
    if (m_pState != NULL)
    {
        delete m_pState;
        m_pState = NULL;
    }
}

void Context::SetState(State* pState)
{
    if (m_pState != NULL)
    {
        delete m_pState;
        m_pState = NULL;
    }
    m_pState = pState;
}

State* Context::GetState()
{
    return m_pState;
}

void Context::Request()
{
    m_pState->Operation(this);
    cout << "当前状态：" << m_pState->GetStateName().c_str() << endl;
}

 

调用代码

StatePatternMemo.cpp

// StatePatternMemo.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include "Context.h"
#include "StateX.h"
#include "StateY.h"

int _tmain(int argc, _TCHAR* argv[])
{
    Context* pContext = new Context(new StateX());

    pContext->Request();
    pContext->Request();
    pContext->Request();
    pContext->Request();

    system("pause");
    return 0;
}

2.3、运行结果：