设计模式-行为型模式-状态模式

本文链接：https://blog.csdn.net/qq_40788199/article/details/125382461

工程源码：

c++设计模式-行为型模式-状态模式https://download.csdn.net/download/qq_40788199/85712693码云：

c++设计模式-行为型模式-状态模式https://gitee.com/gongguixing/c-design-mode.git

1、状态模式的定义与特点

状态（State）模式的定义：对有状态的对象，把复杂的“判断逻辑”提取到不同的状态对象中，允许状态对象在其内部状态发生改变时改变其行为。

状态模式是一种对象行为型模式，其主要优点如下。

结构清晰，状态模式将与特定状态相关的行为局部化到一个状态中，并且将不同状态的行为分割开来，满足“单一职责原则”。
将状态转换显示化，减少对象间的相互依赖。将不同的状态引入独立的对象中会使得状态转换变得更加明确，且减少对象间的相互依赖。
状态类职责明确，有利于程序的扩展。通过定义新的子类很容易地增加新的状态和转换。

状态模式的主要缺点如下。

状态模式的使用必然会增加系统的类与对象的个数。
状态模式的结构与实现都较为复杂，如果使用不当会导致程序结构和代码的混乱。
状态模式对开闭原则的支持并不太好，对于可以切换状态的状态模式，增加新的状态类需要修改那些负责状态转换的源码，否则无法切换到新增状态，而且修改某个状态类的行为也需要修改对应类的源码。

2、状态模式的结构与实现

状态模式把受环境改变的对象行为包装在不同的状态对象里，其意图是让一个对象在其内部状态改变的时候，其行为也随之改变。现在我们来分析其基本结构和实现方法。

1. 模式的结构

状态模式包含以下主要角色。

环境类（Context）角色：也称为上下文，它定义了客户端需要的接口，内部维护一个当前状态，并负责具体状态的切换。
抽象状态（State）角色：定义一个接口，用以封装环境对象中的特定状态所对应的行为，可以有一个或多个行为。
具体状态（Concrete State）角色：实现抽象状态所对应的行为，并且在需要的情况下进行状态切换。

其结构图如图 1 所示。

3、代码实现

3.1、环境类（Context）角色

#ifndef CONTEXT_H
#define CONTEXT_H

#include "istate.h"

// 环境类（Context）角色
// 也称为上下文，它定义了客户端需要的接口，
// 内部维护一个当前状态，并负责具体状态的切换。
class Context
{
public:
    Context();
    ~Context();

    //设置新状态
    void setState(IState *state);

    //读取状态
    IState * getState();

    //对请求做处理
    void Handle();

private:
    IState * mState;
};

#endif // CONTEXT_H

#include "context.h"
#include "concretestatea.h"

Context::Context()
{
    //定义环境类的初始状态
    mState = new ConcreteStateA();
}

Context::~Context()
{
    // 释放最后的状态
    if (mState)
    {
        delete mState;
    }
}

void Context::setState(IState *state)
{
    // 设置新的状态前先示范已有状态
    if (mState)
    {
        delete mState;
        mState = nullptr;
    }

    mState = state;
}

IState *Context::getState()
{
    return mState;
}

void Context::Handle()
{
    if (mState)
    {
        mState->Handle(this);
    }
}

3.2、抽象状态（State）角色

#ifndef ISTATE_H
#define ISTATE_H

class Context;

// 抽象状态（State）角色
// 定义一个接口，用以封装环境对象中的特定状态所对应的行为，可以有一个或多个行为。
class IState
{
public:
    virtual ~IState() {}

    virtual void Handle(Context *p) = 0;
};

#endif // ISTATE_H

3.3、具体状态（Concrete State）角色 A

#ifndef CONCRETESTATEA_H
#define CONCRETESTATEA_H

#include "istate.h"
#include "context.h"

// 具体状态（Concrete State）角色
// 实现抽象状态所对应的行为，并且在需要的情况下进行状态切换。
class ConcreteStateA : public IState
{
public:
    ConcreteStateA();

    void Handle(Context *p) override;
};

#endif // CONCRETESTATEA_H

#include "concretestatea.h"
#include "concretestateb.h"
#include <iostream>

ConcreteStateA::ConcreteStateA()
{

}

void ConcreteStateA::Handle(Context *p)
{
    std::cout << "I am the ConcreteStateA." << std::endl;
    // 将状态切换至B
    p->setState(new ConcreteStateB());
}

3.4、具体状态（Concrete State）角色 B

#ifndef CONCRETESTATEB_H
#define CONCRETESTATEB_H

#include "istate.h"
#include "context.h"

// 具体状态（Concrete State）角色
// 实现抽象状态所对应的行为，并且在需要的情况下进行状态切换。
class ConcreteStateB : public IState
{
public:
    ConcreteStateB();

    void Handle(Context *p) override;

};

#endif // CONCRETESTATEB_H

#include "concretestateb.h"
#include "concretestatec.h"
#include <iostream>

ConcreteStateB::ConcreteStateB()
{

}

void ConcreteStateB::Handle(Context *p)
{
    std::cout << "I am the ConcreteStateB." << std::endl;
    // 将状态切换至C
    p->setState(new ConcreteStateC());
}

3.5、具体状态（Concrete State）角色

#ifndef CONCRETESTATEC_H
#define CONCRETESTATEC_H

#include "istate.h"
#include "context.h"

// 具体状态（Concrete State）角色
// 实现抽象状态所对应的行为，并且在需要的情况下进行状态切换。
class ConcreteStateC : public IState
{
public:
    ConcreteStateC();

    void Handle(Context *p) override;
};

#endif // CONCRETESTATEC_H

#include "concretestatec.h"
#include "concretestatea.h"
#include <iostream>

ConcreteStateC::ConcreteStateC()
{

}

void ConcreteStateC::Handle(Context *p)
{
    std::cout << "I am the ConcreteStateC." << std::endl;
    // 将状态切换至A
    p->setState(new ConcreteStateA());
}

3.6、调用示例

#include <iostream>
#include "context.h"

int main()
{
    // 状态（State）模式的定义：对有状态的对象，
    // 把复杂的“判断逻辑”提取到不同的状态对象中，
    // 允许状态对象在其内部状态发生改变时改变其行为。

    // 实例化环境
    Context * p = new Context();
    //对请求做处理
    p->Handle();
    p->Handle();
    p->Handle();
    p->Handle();
    p->Handle();
    p->Handle();
    delete p;

    return 0;
}