【设计模式】深入理解状态模式：如何优雅地管理对象的状态和行为，打造流畅的角色状态管理系统，深入分析上下文、状态和具体状态的作用，从理论到实践的完整指南

已于 2024-01-17 22:00:01 修改
阅读量831 收藏 14
点赞数 18
分类专栏： C++随想录 文章标签： 设计模式 c++ 状态模式 码蚁软件 架构师 游戏
于 2024-01-17 21:52:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mars1199/article/details/135661012
版权

目录

前言：

一、原理及示例代码：

二、结构图

三、使用场景：

场景1：

场景2：

场景3：

四、优缺点：

状态模式的优点包括：

状态模式的缺点包括：

五、常见面试题：

什么是状态模式？

请解释状态模式的工作原理。

请举例说明状态模式在实际项目中的应用。

状态模式和策略模式有何区别？

如何实现状态模式的状态切换？

状态模式和观察者模式有何异同？

请说明状态模式的优缺点。

请说明状态模式的角色及其职责。

请说明状态模式和有限状态机(FSM)的关系。

请说明状态模式在实际项目中的应用场景。

前言：

状态模式是一种行为型设计模式，它允许对象在内部状态发生改变时改变其行为。这种模式将对象的状态封装成独立的类，并将状态的改变委托给表示不同状态的对象。状态模式的核心思想是将对象的行为与其状态分离，使得对象可以根据其内部状态的变化而改变其行为，同时避免了使用大量的条件语句来判断对象的状态。

状态模式通常包括以下几个角色：

  • Context（上下文）：维护一个状态对象的引用，定义了客户感兴趣的接口，通常会将请求委托给当前状态对象处理。
  • State（状态）：定义了一个接口，用于封装与Context的一个特定状态相关的行为。
  • ConcreteState（具体状态）：实现State接口，每个具体状态都提供了对应于一个状态的行为。

状态模式的优点包括：

  • 将与状态相关的行为局部化到状态类中，使得状态转换更加清晰和简单。
  • 通过将状态对象独立化，使得添加新的状态变得更加容易。

然而，状态模式也存在一些缺点，例如可能会导致系统中类的数量增加，因此在实际应用中需要权衡使用。

状态模式在实际项目中有着广泛的应用，例如电梯控制系统、游戏角色状态管理、订单状态管理等。通过状态模式，可以更好地管理对象的状态和行为，使得系统更加灵活和易于扩展。

一、原理及示例代码：

状态模式是一种行为设计模式，它允许对象在内部状态发生改变时改变它的行为。这种模式的关键思想是将状态封装成独立的类，然后将对象的行为委托给当前状态对象。这样，当对象的状态发生改变时，它的行为也会相应地改变。

在状态模式中，通常会有一个Context类和多个State类。Context类包含一个指向当前状态对象的引用，并且会将请求委托给当前状态对象。State类定义了一个接口，用于封装特定状态下的行为。每个具体的状态类都实现了State接口，并且根据需要来改变Context对象的状态。

下面是一个简单的C++示例代码，演示了状态模式的使用：

#include <iostream>

class State {
public:
    virtual void handle() = 0;
};

class ConcreteStateA : public State {
public:
    void handle() override {
        std::cout << "Handling in State A" << std::endl;
    }
};

class ConcreteStateB : public State {
public:
    void handle() override {
        std::cout << "Handling in State B" << std::endl;
    }
};

class Context {
private:
    State* state;

public:
    void setState(State* newState) {
        state = newState;
    }

    void request() {
        state->handle();
    }
};

int main() {
    Context context;
    ConcreteStateA stateA;
    ConcreteStateB stateB;

    context.setState(&stateA);
    context.request();

    context.setState(&stateB);
    context.request();

    return 0;
}

在这个示例代码中，我们定义了State接口，并创建了两个具体的状态类ConcreteStateA和ConcreteStateB。然后，我们定义了Context类，它包含一个指向当前状态对象的引用，并且将请求委托给当前状态对象。在main函数中，我们创建了Context对象并设置了不同的状态，然后调用request方法来处理请求。根据当前状态的不同，输出结果也会不同。

二、结构图

以下是状态模式的结构图：

  +-----------------+        +------------------+
  |   Context       |        |      State       |
  +-----------------+        +------------------+
  | -state: State   |        |                  |
  +-----------------+        +------------------+
  | +request()      |        | +handle()        |
  | +setState()     |        +------------------+
  +-----------------+
            |
            |
            |
            |
            | uses
            |
            |
            |
            V
  +-----------------+
  | ConcreteStateA  |
  +-----------------+
  | +handle()       |
  +-----------------+
  
  +-----------------+
  | ConcreteStateB  |
  +-----------------+
  | +handle()       |
  +-----------------+

在这个结构图中，Context类包含一个指向当前状态对象的引用，并且有一个用于委托请求的方法request()和一个用于改变状态的方法setState()。State接口定义了一个用于处理请求的方法handle()。ConcreteStateA和ConcreteStateB是具体的状态类，它们实现了State接口，根据当前状态来处理请求。

三、使用场景：

状态模式通常在以下情况下使用：

  1. 对象的行为取决于其状态，并且需要在运行时根据状态改变行为。
  2. 一个对象有多个状态，且在不同状态下会有不同的行为。
  3. 代码中包含大量与对象状态相关的条件语句，这些条件语句会导致代码难以维护和理解。
  4. 需要将状态转换的逻辑封装在状态类中，以便于复用和扩展。

举例来说，状态模式可以应用在以下场景中：

  • 文件编辑器中，根据当前的编辑模式（如插入模式、命令模式等），光标的移动和输入字符的行为会有所不同。
  • 自动售货机根据当前的库存状态（充足、缺货等）来决定是否接受订单。
  • 游戏中角色的状态（如正常、受伤、死亡）会影响其行为和可用的操作。

总的来说，如果你的系统中包含多个状态，并且对象的行为会随着状态的改变而改变，那么状态模式可能是一个合适的选择。它可以帮助你将状态相关的逻辑封装到独立的状态类中，使代码更加清晰、灵活和易于维护。

场景1：

演示了文件编辑器中根据当前的编辑模式，光标的移动和输入字符的行为会有所不同。

#include <iostream>
#include <string>

// 状态接口
class EditModeState {
public:
    virtual void moveCursor() = 0;
    virtual void inputChar(char c) = 0;
};

// 具体状态类：插入模式
class InsertModeState : public EditModeState {
public:
    void moveCursor() override {
        std::cout << "Moving cursor in insert mode" << std::endl;
    }

    void inputChar(char c) override {
        std::cout << "Inserting character '" << c << "' in insert mode" << std::endl;
    }
};

// 具体状态类：命令模式
class CommandModeState : public EditModeState {
public:
    void moveCursor() override {
        std::cout << "Moving cursor in command mode" << std::endl;
    }

    void inputChar(char c) override {
        if (c == 'i') {
            std::cout << "Switching to insert mode" << std::endl;
        } else {
            std::cout << "Executing command '" << c << "' in command mode" << std::endl;
        }
    }
};

// 上下文类
class Editor {
private:
    EditModeState* currentState;

public:
    Editor() {
        currentState = new CommandModeState();  // 初始状态为命令模式
    }

    void setState(EditModeState* newState) {
        currentState = newState;
    }

    void moveCursor() {
        currentState->moveCursor();
    }

    void inputChar(char c) {
        currentState->inputChar(c);
    }
};

int main() {
    Editor editor;

    editor.moveCursor();  // 在命令模式下移动光标
    editor.inputChar('i');  // 在命令模式下输入'i'，切换到插入模式
    editor.moveCursor();  // 在插入模式下移动光标
    editor.inputChar('a');  // 在插入模式下输入字符'a'

    return 0;
}

在这个示例中，我们定义了EditModeState接口作为状态的抽象，然后创建了两个具体的状态类InsertModeState和CommandModeState，分别表示插入模式和命令模式。Editor类作为上下文类，包含了当前的编辑模式，并且根据当前编辑模式委托光标移动和输入字符的行为。

在main函数中，我们创建了一个Editor对象，并且演示了在不同的编辑模式下移动光标和输入字符的行为。根据当前的编辑模式不同，输出结果也会有所不同。

场景2：

演示了自动售货机根据当前的库存状态来决定是否接受订单。

#include <iostream>
#include <string>

// 状态接口
class VendingMachineState {
public:
    virtual void processOrder() = 0;
};

// 具体状态类：库存充足
class InStockState : public VendingMachineState {
public:
    void processOrder() override {
        std::cout << "Processing order as the item is in stock" << std::endl;
    }
};

// 具体状态类：缺货
class OutOfStockState : public VendingMachineState {
public:
    void processOrder() override {
        std::cout << "Cannot process order as the item is out of stock" << std::endl;
    }
};

// 上下文类
class VendingMachine {
private:
    VendingMachineState* currentState;

public:
    VendingMachine() {
        currentState = new InStockState();  // 初始状态为库存充足
    }

    void setState(VendingMachineState* newState) {
        currentState = newState;
    }

    void processOrder() {
        currentState->processOrder();
    }
};

int main() {
    VendingMachine vendingMachine;

    vendingMachine.processOrder();  // 处理订单（库存充足）
    
    vendingMachine.setState(new OutOfStockState());  // 切换状态为缺货
    vendingMachine.processOrder();  // 处理订单（缺货）

    return 0;
}

在这个示例中，我们定义了VendingMachineState接口作为状态的抽象，然后创建了两个具体的状态类InStockState和OutOfStockState，分别表示库存充足和缺货状态。VendingMachine类作为上下文类，包含了当前的库存状态，并且根据当前状态来处理订单。

在main函数中，我们创建了一个VendingMachine对象，并且演示了在不同的库存状态下处理订单的行为。根据当前的库存状态不同，输出结果也会有所不同。

场景3：

演示了游戏中角色的状态（如正常、受伤、死亡）对其行为和可用的操作的影响。

#include <iostream>
#include <string>

// 状态接口
class CharacterState {
public:
    virtual void performAction() = 0;
};

// 具体状态类：正常状态
class NormalState : public CharacterState {
public:
    void performAction() override {
        std::cout << "Performing normal action" << std::endl;
    }
};

// 具体状态类：受伤状态
class InjuredState : public CharacterState {
public:
    void performAction() override {
        std::cout << "Performing injured action" << std::endl;
    }
};

// 具体状态类：死亡状态
class DeadState : public CharacterState {
public:
    void performAction() override {
        std::cout << "Cannot perform any action as the character is dead" << std::endl;
    }
};

// 上下文类
class Character {
private:
    CharacterState* currentState;

public:
    Character() {
        currentState = new NormalState();  // 初始状态为正常
    }

    void setState(CharacterState* newState) {
        currentState = newState;
    }

    void performAction() {
        currentState->performAction();
    }
};

int main() {
    Character player;

    player.performAction();  // 执行角色动作（正常状态）
    
    player.setState(new InjuredState());  // 切换状态为受伤
    player.performAction();  // 执行角色动作（受伤状态）

    player.setState(new DeadState());  // 切换状态为死亡
    player.performAction();  // 执行角色动作（死亡状态）

    return 0;
}

在这个示例中，我们定义了CharacterState接口作为角色状态的抽象，然后创建了三个具体的状态类NormalState、InjuredState和DeadState，分别表示角色的正常、受伤和死亡状态。Character类作为上下文类，包含了当前的角色状态，并且根据当前状态来执行角色的动作。

在main函数中，我们创建了一个Character对象，并且演示了在不同的角色状态下执行角色动作的行为。根据当前的角色状态不同，输出结果也会有所不同。

四、优缺点：

状态模式的优点包括：

  1. 清晰的状态转换：状态模式可以清晰地定义对象在不同状态下的行为，使得状态转换变得简单明了。

  2. 避免大量的条件语句：状态模式可以避免使用大量的条件语句来判断对象的状态，使得代码更加清晰和易于维护。

  3. 开放/封闭原则：状态模式符合开放/封闭原则，可以方便地扩展新的状态类，而不需要修改已有的代码。

  4. 状态切换的灵活性：状态模式可以使得状态切换变得更加灵活，可以根据具体的状态来改变对象的行为。

状态模式的缺点包括：

  1. 类的数量增加：引入状态模式会增加系统中类的数量，尤其是在有多个状态和行为的情况下，可能会导致类的数量增加较多。

  2. 状态之间的关系：如果状态之间存在复杂的关系，可能会导致状态模式变得复杂，不易管理。

  3. 状态的切换：在状态转换较为复杂的情况下，可能会导致状态切换的管理变得困难。

总的来说，状态模式在需要管理对象的状态，并且状态之间有明显的行为差异时非常有用，但在状态较为简单或状态之间关系复杂的情况下，可能需要权衡使用状态模式的利弊。

五、常见面试题：

当面试中涉及到状态模式时，通常会涉及以下一些常见问题。下面是一些可能的面试问题以及对应的答案解析：

  1. 什么是状态模式？
    答案解析：状态模式是一种行为型设计模式，用于允许对象在内部状态发生改变时改变其行为。它将对象的状态封装成独立的类，并将状态的改变委托给表示不同状态的对象。
  2. 请解释状态模式的工作原理。
    答案解析：状态模式通过将状态封装成独立的类，使得对象可以在不同状态下有不同的行为。当对象的状态发生改变时，会切换到对应的状态类，从而改变对象的行为。
  3. 请举例说明状态模式在实际项目中的应用。
    答案解析：可以举例说明状态模式在游戏中角色状态管理、电梯控制系统、订单状态管理等实际项目中的应用。
  4. 状态模式和策略模式有何区别？
    答案解析：状态模式和策略模式都涉及到对象的行为随着状态或策略的改变而改变。状态模式关注对象的内部状态变化，而策略模式关注对象的行为算法的变化。
  5. 如何实现状态模式的状态切换？
    答案解析：状态模式的状态切换可以通过上下文对象持有状态对象的引用，并在需要切换状态时，将引用指向新的状态对象来实现。
  6. 状态模式和观察者模式有何异同？
    答案解析：状态模式和观察者模式都涉及到对象状态的变化。状态模式关注对象内部状态的变化，而观察者模式关注对象状态的变化对其他对象的通知。
  7. 请说明状态模式的优缺点。
    答案解析：可以参考之前我提供的关于状态模式的优缺点的回答。
  8. 请说明状态模式的角色及其职责。
    答案解析：状态模式的角色包括上下文(Context)、抽象状态(State)、具体状态(ConcreteState)等。上下文负责维护状态对象，并根据当前状态执行对应的行为。抽象状态定义了状态的接口，具体状态实现了具体的状态行为。
  9. 请说明状态模式和有限状态机(FSM)的关系。
    答案解析：状态模式可以用来实现有限状态机，有限状态机是一种数学模型，用于描述对象在不同状态下的转换关系。状态模式可以帮助实现有限状态机中的状态和状态转换。
  10. 请说明状态模式在实际项目中的应用场景。
  •    答案解析：可以举例说明状态模式在游戏开发、电梯控制系统、订单状态管理等实际项目中的应用场景，以及如何使用状态模式来管理对象的状态和行为。

更多交流和疑问可以评论区留言，或者到以下交流👇👇👇 

五木大大
关注
  • 18
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

五木大大

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值