状态模式（State Pattern）

状态模式（State Pattern）是一种行为设计模式，它允许对象在内部状态改变时改变其行为。状态模式将状态的行为封装在独立的状态对象中，这样使得状态之间可以相互替换，从而改变对象的行为。

主要特点

封装状态: 将状态的行为封装在独立的状态类中，使得每个状态都可以独立变化，而不会影响其他状态。
状态转换：对象的行为是由其内部状态决定的，当状态改变时，对象的行为也会随之改变。
简化复杂状态逻辑: 将与状态相关的行为分散到不同的状态类中，避免了大量的条件语句，使代码更加清晰和易于维护。

示例

以红绿灯为例，我们可以使用状态模式来模拟红绿灯的状态转换。红绿灯通常有三个状态：红灯、黄灯和绿灯，每个状态都有其特定的行为和下一个状态。

状态接口

首先，我们定义一个状态接口，用于表示红绿灯的不同状态。

#include <iostream>
#include <memory>

// 状态接口
class TrafficLightState {
public:
    virtual ~TrafficLightState() = default;
    virtual void handle() = 0;
    virtual std::shared_ptr<TrafficLightState> next() = 0;
};

具体状态类

接着，我们定义具体的状态类，分别表示红灯、黄灯和绿灯。

// 红灯状态
class RedLightState : public TrafficLightState {
public:
    void handle() override {
        std::cout << "Red light - Stop!" << std::endl;
    }

    std::shared_ptr<TrafficLightState> next() override {
        return std::make_shared<GreenLightState>();
    }
};

// 绿灯状态
class GreenLightState : public TrafficLightState {
public:
    void handle() override {
        std::cout << "Green light - Go!" << std::endl;
    }

    std::shared_ptr<TrafficLightState> next() override {
        return std::make_shared<YellowLightState>();
    }
};

// 黄灯状态
class YellowLightState : public TrafficLightState {
public:
    void handle() override {
        std::cout << "Yellow light - Slow down!" << std::endl;
    }

    std::shared_ptr<TrafficLightState> next() override {
        return std::make_shared<RedLightState>();
    }
};

上下文类

然后，我们定义上下文类，用于管理红绿灯的状态，并提供一个方法来切换状态。

// 红绿灯类
class TrafficLight {
public:
    TrafficLight() : state(std::make_shared<RedLightState>()) {}

    void change() {
        state->handle();
        state = state->next();
    }

private:
    std::shared_ptr<TrafficLightState> state;
};

主函数测试

最后，我们在主函数中创建一个TrafficLight对象，并多次调用change方法，模拟红绿灯的状态变化。

int main() {
    TrafficLight trafficLight;

    for (int i = 0; i < 6; ++i) {
        trafficLight.change();
    }

    return 0;
}

解释

1. TrafficLightState：这是一个状态接口，定义了两个纯虚函数handle和next。handle用于表示当前状态的行为，next用于获取下一个状态。

2. RedLightState、GreenLightState和YellowLightState：这三个类是具体的状态类，分别实现了红灯、绿灯和黄灯的行为，以及状态转换的方法。

3. TrafficLight：这是上下文类，它维护一个指向当前状态的指针，并提供一个change方法来处理状态的转换。在change方法中，调用当前状态的handle方法，然后将状态切换到下一个状态。

4. 主函数：

   • 创建一个TrafficLight对象。
   • 多次调用change方法，模拟红绿灯的状态变化，观察输出结果。

总结

通过状态模式，我们可以清晰地定义红绿灯的状态和状态转换逻辑，使得代码结构更加清晰和易于维护。每个状态的行为被封装在独立的状态类中，当红绿灯的状态发生变化时，只需要切换到相应的状态对象，而不需要在上下文类中处理复杂的状态转换逻辑。状态模式很好地实现了对象行为的动态改变，适用于状态较多且需要频繁切换的场景。

优化

将 next 函数放在 TrafficLightState 接口中或具体状态类中是可以的，但更好的做法是将状态转换的逻辑放在上下文类 TrafficLight 中。这是因为状态转换通常涉及多个状态之间的关系，而这些关系更适合由上下文类管理，从而使状态类更加专注于各自的行为。

优化后的设计

将状态转换的逻辑移到 TrafficLight 类中，我们可以避免在状态类中硬编码状态转换规则，使得状态类更加独立和单一职责。

示例代码

状态接口

#include <iostream>
#include <memory>

// 状态接口
class TrafficLightState {
public:
    virtual ~TrafficLightState() = default;
    virtual void handle() = 0;
};

具体状态类

// 前向声明 TrafficLight 类
class TrafficLight;

// 红灯状态
class RedLightState : public TrafficLightState {
public:
    void handle() override {
        std::cout << "Red light - Stop!" << std::endl;
    }
};

// 绿灯状态
class GreenLightState : public TrafficLightState {
public:
    void handle() override {
        std::cout << "Green light - Go!" << std::endl;
    }
};

// 黄灯状态
class YellowLightState : public TrafficLightState {
public:
    void handle() override {
        std::cout << "Yellow light - Slow down!" << std::endl;
    }
};

上下文类

class TrafficLight {
public:
    TrafficLight() {
        redLightState = std::make_shared<RedLightState>();
        greenLightState = std::make_shared<GreenLightState>();
        yellowLightState = std::make_shared<YellowLightState>();
        state = redLightState;
    }

    void change() {
        state->handle();
        next();
    }

private:
    void next() {
        if (state == redLightState) {
            state = greenLightState;
        } else if (state == greenLightState) {
            state = yellowLightState;
        } else if (state == yellowLightState) {
            state = redLightState;
        }
    }

    std::shared_ptr<TrafficLightState> state;
    std::shared_ptr<TrafficLightState> redLightState;
    std::shared_ptr<TrafficLightState> greenLightState;
    std::shared_ptr<TrafficLightState> yellowLightState;
};

主函数测试

int main() {
    TrafficLight trafficLight;

    for (int i = 0; i < 6; ++i) {
        trafficLight.change();
    }

    return 0;
}

解释

1. TrafficLightState：这是一个状态接口，定义了一个纯虚函数 handle，表示状态的行为。

2. RedLightState、GreenLightState 和 YellowLightState：这三个类是具体的状态类，分别实现了红灯、绿灯和黄灯的行为。

3. TrafficLight：这是上下文类，维护一个指向当前状态的指针以及所有状态的实例。提供一个 change 方法来处理状态的转换。next 方法在 TrafficLight 类内部实现状态之间的转换逻辑。

4. 主函数：

   • 创建一个 TrafficLight 对象。
   • 多次调用 change 方法，模拟红绿灯的状态变化，观察输出结果。

总结

通过将状态转换逻辑放在上下文类中，状态类更加独立，职责更加单一。这种设计使得状态类只关注各自的行为，而状态转换的复杂性由上下文类管理，增强了系统的灵活性和可维护性。