状态模式（State Pattern）

状态模式（State Pattern） 如果任务的执行过程是有多个不同状态的（比如初始化、运行中、完成等），你可以使用状态模式。每个状态可以有不同的行为，使得任务的状态管理更加清晰和可维护。

示例：

class TaskState {
public:
    virtual void handle() = 0;  // 处理状态
};

class InitializedState : public TaskState {
public:
    void handle() override {
        // 初始化状态下的处理
    }
};

class RunningState : public TaskState {
public:
    void handle() override {
        // 运行状态下的处理
    }
};

class Task {
private:
    TaskState *state;

public:
    void setState(TaskState *state) {
        this->state = state;
    }

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

---

状态模式（State Pattern）是一种行为设计模式，它允许对象在内部状态改变时改变其行为，从而让对象看起来像是改变了其类。这种模式非常适合处理对象在不同状态下具有不同行为的场景。

状态模式的核心概念

1. Context（上下文）：

   • 包含一个对状态对象的引用，通过这个引用调用状态对象的方法。
   • 客户端通过上下文对象与状态对象交互。

2. State（状态接口）：

   • 定义了一个接口，用于封装与状态相关的操作。
   • 所有具体状态类都实现这个接口。

3. ConcreteState（具体状态类）：

   • 实现了状态接口，具体定义了对象在某个状态下的行为。
   • 可以访问上下文对象，以便在需要时改变上下文的状态。

示例代码解析

以下是一个完整的状态模式示例，包括上下文类、状态接口和具体状态类。

1. 状态接口（State）

class TaskState {
public:
    virtual ~TaskState() {}
    virtual void handle(Task* task) = 0;  // 处理状态
};

2. 具体状态类（ConcreteState）

class InitializedState : public TaskState {
public:
    void handle(Task* task) override {
        std::cout << "Task is in Initialized State" << std::endl;
        // 初始化状态下的处理逻辑
        // 可以在这里改变任务的状态
        task->setState(new RunningState());
    }
};

class RunningState : public TaskState {
public:
    void handle(Task* task) override {
        std::cout << "Task is in Running State" << std::endl;
        // 运行状态下的处理逻辑
        // 可以在这里改变任务的状态
        task->setState(new CompletedState());
    }
};

class CompletedState : public TaskState {
public:
    void handle(Task* task) override {
        std::cout << "Task is in Completed State" << std::endl;
        // 完成状态下的处理逻辑
        // 任务完成，不再改变状态
    }
};

3. 上下文类（Context）

class Task {
private:
    TaskState* state;

public:
    Task() : state(nullptr) {}

    void setState(TaskState* newState) {
        if (state) {
            delete state;  // 释放旧状态
        }
        state = newState;
    }

    void run() {
        if (state) {
            state->handle(this);  // 调用当前状态的处理方法
        }
    }

    ~Task() {
        if (state) {
            delete state;  // 释放状态对象
        }
    }
};

使用示例

以下是如何使用状态模式来管理任务状态的示例：

#include <iostream>

int main() {
    // 创建任务对象
    Task task;

    // 设置初始状态为初始化状态
    task.setState(new InitializedState());

    // 运行任务
    task.run();  // 输出: Task is in Initialized State
    task.run();  // 输出: Task is in Running State
    task.run();  // 输出: Task is in Completed State

    return 0;
}

输出

Task is in Initialized State
Task is in Running State
Task is in Completed State

状态模式的用途

1. 清晰的状态管理：

   • 状态模式将每个状态的行为封装在独立的类中，使得状态管理更加清晰和可维护。
   • 每个状态类只关注自己的行为，符合单一职责原则。

2. 动态状态切换：

   • 对象可以在运行时动态切换状态，而不需要在上下文类中编写大量的条件语句。
   • 状态的切换逻辑由状态类本身管理，减少了上下文类的复杂性。

3. 扩展性：

   • 添加新的状态时，只需添加一个新的状态类，而不需要修改现有的上下文类或状态类。
   • 符合开闭原则（对扩展开放，对修改封闭）。

与状态观测器的关系

状态模式和状态观测器（Observer Pattern）是两种不同的设计模式，但它们可以结合使用：

• 状态模式：

  • 主要用于管理对象的内部状态和行为。
  • 通过状态类的切换来改变对象的行为。

• 状态观测器（Observer Pattern）：

  • 主要用于实现对象之间的依赖关系，当一个对象的状态改变时，所有依赖于它的对象都会得到通知并自动更新。
  • 适用于多对多的依赖关系，例如事件驱动系统。

结合使用示例

假设你需要在任务状态改变时通知其他对象，可以结合状态模式和状态观测器模式：

1. 定义 Observer 接口：

   class Observer {
   public:
       virtual void update(const std::string& message) = 0;
   };

2. 定义 Subject 类：

   class Subject {
   private:
       std::vector<Observer*> observers;
   public:
       void attach(Observer* observer) {
           observers.push_back(observer);
       }
   
       void notify(const std::string& message) {
           for (Observer* observer : observers) {
               observer->update(message);
           }
       }
   };

3. 让 Task 类继承 Subject：

   class Task : public Subject {
   private:
       TaskState* state;
   
   public:
       Task() : state(nullptr) {}
   
       void setState(TaskState* newState) {
           if (state) {
               delete state;
           }
           state = newState;
           notify("Task state changed");  // 通知观察者
       }
   
       void run() {
           if (state) {
               state->handle(this);
           }
       }
   
       ~Task() {
           if (state) {
               delete state;
           }
       }
   };

4. 定义具体的 Observer：

   class TaskLogger : public Observer {
   public:
       void update(const std::string& message) override {
           std::cout << "Log: " << message << std::endl;
       }
   };

5. 使用示例：

   int main() {
       Task task;
       task.attach(new TaskLogger());
   
       task.setState(new InitializedState());
       task.run();
       task.run();
       task.run();
   
       return 0;
   }

输出

Log: Task state changed
Task is in Initialized State
Log: Task state changed
Task is in Running State
Log: Task state changed
Task is in Completed State

总结

• 状态模式：用于管理对象的内部状态和行为，通过状态类的切换来改变对象的行为。
• 状态观测器模式：用于实现对象之间的依赖关系，当一个对象的状态改变时，通知所有依赖于它的对象。
• 结合使用：可以通过状态模式管理状态，同时使用状态观测器模式通知其他对象状态的变化。

希望这些解释和示例能帮助你更好地理解状态模式及其用途。

---

来源：CSDN 原文，首次发布于 2025-03-26。