【Q&A】QT有哪些状态模式的设计？

在C++和Qt开发中，状态模式是一种很实用的设计模式，它允许对象在内部状态改变时改变其行为，看起来就像对象修改了自身的类。下面为你介绍几种常见的状态模式设计实现：

1. 自定义状态类实现状态模式

通过自定义状态类，可以灵活地定义不同状态下的行为。以下是一个简单示例：

#include <iostream>
#include <string>

// 前向声明
class Context;

// 抽象状态类
class State {
public:
    virtual void handle(Context* context) = 0;
    virtual ~State() {}
};

// 具体状态类A
class ConcreteStateA : public State {
public:
    void handle(Context* context) override;
};

// 具体状态类B
class ConcreteStateB : public State {
public:
    void handle(Context* context) override;
};

// 上下文类
class Context {
private:
    State* currentState;
public:
    Context() : currentState(new ConcreteStateA()) {}
    ~Context() { delete currentState; }

    void setState(State* state) {
        delete currentState;
        currentState = state;
    }

    void request() {
        currentState->handle(this);
    }
};

// 具体状态类A的处理方法
void ConcreteStateA::handle(Context* context) {
    std::cout << "Handling state A. Transitioning to state B." << std::endl;
    context->setState(new ConcreteStateB());
}

// 具体状态类B的处理方法
void ConcreteStateB::handle(Context* context) {
    std::cout << "Handling state B. Transitioning to state A." << std::endl;
    context->setState(new ConcreteStateA());
}

int main() {
    Context context;
    for (int i = 0; i < 3; ++i) {
        context.request();
    }
    return 0;
}

在这个示例里，State 是抽象状态类，ConcreteStateA 和 ConcreteStateB 是具体状态类，Context 是上下文类。Context 类持有当前状态，并且可以通过 request 方法调用当前状态的 handle 方法。

2. 使用 QStateMachine 和 QAbstractState

Qt提供了 QStateMachine 和 QAbstractState 类，可方便地实现状态模式。以下是一个使用 QStateMachine 的示例：

#include <QApplication>
#include <QStateMachine>
#include <QState>
#include <QFinalState>
#include <QPushButton>
#include <QVBoxLayout>
#include <QWidget>

int main(int argc, char *argv[]) {
    QApplication a(argc, argv);

    // 创建主窗口和布局
    QWidget window;
    QVBoxLayout *layout = new QVBoxLayout(&window);
    QPushButton *button = new QPushButton("Trigger State", &window);
    layout->addWidget(button);

    // 创建状态机
    QStateMachine machine;

    // 创建状态
    QState *state1 = new QState();
    QState *state2 = new QState();
    QFinalState *finalState = new QFinalState();

    // 定义状态转换
    state1->addTransition(button, &QPushButton::clicked, state2);
    state2->addTransition(button, &QPushButton::clicked, finalState);

    // 为状态设置属性
    state1->assignProperty(button, "text", "State 1");
    state2->assignProperty(button, "text", "State 2");

    // 将状态添加到状态机
    machine.addState(state1);
    machine.addState(state2);
    machine.addState(finalState);
    machine.setInitialState(state1);

    // 连接状态机的完成信号
    QObject::connect(&machine, &QStateMachine::finished, &a, &QApplication::quit);

    // 启动状态机
    machine.start();

    window.show();
    return a.exec();
}

在这个例子中，QStateMachine 管理状态的转换，QState 表示具体的状态。通过 addTransition 方法可以定义状态之间的转换条件，当按钮被点击时，状态机会在不同状态之间进行切换。

3. 基于信号和槽实现状态模式

在Qt中，还可以利用信号和槽机制来实现状态模式。以下是一个简单示例：

#include <QObject>
#include <QDebug>

// 前向声明
class StateMachine;

// 抽象状态类
class State : public QObject {
    Q_OBJECT
public:
    explicit State(StateMachine* machine, QObject* parent = nullptr) : QObject(parent), machine(machine) {}
    virtual void handle() = 0;

protected:
    StateMachine* machine;
};

// 具体状态类A
class ConcreteStateA : public State {
    Q_OBJECT
public:
    explicit ConcreteStateA(StateMachine* machine, QObject* parent = nullptr) : State(machine, parent) {}
    void handle() override;
};

// 具体状态类B
class ConcreteStateB : public State {
    Q_OBJECT
public:
    explicit ConcreteStateB(StateMachine* machine, QObject* parent = nullptr) : State(machine, parent) {}
    void handle() override;
};

// 状态机类
class StateMachine : public QObject {
    Q_OBJECT
public:
    StateMachine(QObject* parent = nullptr) : QObject(parent), currentState(new ConcreteStateA(this)) {}
    ~StateMachine() { delete currentState; }

    void setState(State* state) {
        delete currentState;
        currentState = state;
    }

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

private:
    State* currentState;
};

// 具体状态类A的处理方法
void ConcreteStateA::handle() {
    qDebug() << "Handling state A. Transitioning to state B.";
    machine->setState(new ConcreteStateB(machine));
}

// 具体状态类B的处理方法
void ConcreteStateB::handle() {
    qDebug() << "Handling state B. Transitioning to state A.";
    machine->setState(new ConcreteStateA(machine));
}

#include "main.moc"

int main(int argc, char *argv[]) {
    QCoreApplication a(argc, argv);

    StateMachine machine;
    for (int i = 0; i < 3; ++i) {
        machine.request();
    }

    return a.exec();
}

在这个示例中，State 是抽象状态类，ConcreteStateA 和 ConcreteStateB 是具体状态类，StateMachine 是状态机类。状态机通过 request 方法调用当前状态的 handle 方法，并且在状态转换时更新当前状态。

这些示例展示了在C++和Qt中实现状态模式的不同方式，你可以根据具体需求选择合适的实现方法。