Question

有一台状态机（称为外部）。这台机器有两种状态 - 第一种和最后一种。第一个州是自定义实施的。在第一个状态内，创建了另一个状态机（称为内部），在本例中什么都不做。

具有两种状态的外部状态机：

  #include <QDebug>
  #include <QCoreApplication>
  #include <QTimer>
  #include <custom_outer_state.hpp>
  #include <QFinalState>
  #include "a.hpp"

  class Functor
  {
  public:
     void operator()()
     {
        // just emits a signal
        TestObject outerTestObject;

        // create outer state machine with all states
        QStateMachine outerStateMachine;
        CustomOuterState *state1 = new CustomOuterState();
        QFinalState *state2 = new QFinalState();
        state1->addTransition(&outerTestObject, SIGNAL(testObjectSignal()), state2);
        outerStateMachine.addState(state1);
        outerStateMachine.addState(state2);
        outerStateMachine.setInitialState(state1);
        outerStateMachine.start();

        // process state machine transitions
        QCoreApplication::processEvents();
        qDebug() << &outerStateMachine << ": Outer state machine first state " <<  outerStateMachine.configuration();
        outerTestObject.testObjectSignal();
        QCoreApplication::processEvents();
        qDebug() << &outerStateMachine << ": Outer state machine second state " <<  outerStateMachine.configuration();
     }
  };

  int main(int argc, char *argv[])
  {
    QCoreApplication app(argc, argv);
    QTimer::singleShot(0, Functor());
    return QCoreApplication::exec();
  }

自定义状态：

  #ifndef CUSTOM_OUTER_STATE_H
  #define CUSTOM_OUTER_STATE_H

  #include <QState>
  #include <QStateMachine>

  class CustomOuterState : public QState
  {
     Q_OBJECT
  public:
     virtual void onEntry(QEvent * event)
     {
        // create inner state machine
        machine = new QStateMachine();
        /*
         * some operations with the machine
         */
     }
  private:
     QStateMachine* machine;
  };

  #endif

测试对象只发出一个信号：

  #ifndef A_H
  #define A_H

  #include <QObject>

  class TestObject : public QObject
  {
     Q_OBJECT
  signals:
     void testObjectSignal();
  };

  #endif

所以这段代码按预期工作 - 外部状态机从第一个状态转到最终状态：

  QStateMachine(0x7fffc00f0a20) : Outer state machine first state  QSet(CustomOuterState(0xe0a380) ) 
  QStateMachine(0x7fffc00f0a20) : Outer state machine second state  QSet(QFinalState(0xe0a460) )

但是在自定义状态中有一点变化 - 将this（它是QState的子类）传递给内部状态机构造函数

  -        machine = new QStateMachine();
  +        machine = new QStateMachine(this);

结果是外部状态机不想进行转换 - 尽管发送了转换信号，它仍处于第一个状态

  QStateMachine(0x7fff219edcb0) : Outer state machine first state  QSet(CustomOuterState(0x1fc4380) ) 
  QStateMachine(0x7fff219edcb0) : Outer state machine second state  QSet(CustomOuterState(0x1fc4380) )

解决方案很简单 - 只需删除内部状态机，一切正常。但问题是为什么坏事会发生。

那么，为什么将this（{1}}的子类添加到内部状态机构造函数结果中，以便外部状态机不会我想过渡？

Answer 1

您正在尝试从状态的事件处理程序修改状态机的状态图。那状态机不支持。由于QStateMachine是一个QState，因此将其添加为子项时，您需要修改状态图。

调用onEntry时，状态图如下所示：
statechart before
在onEntry期间，您将其更改为类似以下内容的内容。 machine不是一个初始状态，它只是一个悬空，无用的状态。即使它没有悬空，它仍然无法使用，因为它是在状态转换期间添加的 statechart after

由于QStateMachine是QState，当你使它成为状态的直接子时，它就成为该状态的子状态。如果你想要的只是使用状态作为状态机的容器，你可以在父和状态之间插入一个介入的非状态对象。

// https://github.com/KubaO/stackoverflown/tree/master/questions/statemachine-nested-32619103
#include <QtCore>

struct OuterState : QState
{
   QStateMachine * machine { nullptr };
   virtual void onEntry(QEvent *) Q_DECL_OVERRIDE
   {
      // through an intervening container
      auto container = new QObject(this);
      machine = new QStateMachine(container);
   }
   OuterState(QState * parent = 0) : QState(parent) {}
};

最后，调用processEvents的伪同步代码是不必要的。您可以在输入状态等时执行操作。回想一下，由于信号是一种可调用的方法，就像插槽一样，您可以将信号连接到信号。事实上，既然你想要实现的只是一个无条件的过渡，你也可以使用它。

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

   // create outer state machine with all states
   QStateMachine outerStateMachine;
   OuterState state1 { &outerStateMachine };
   QFinalState state2 { &outerStateMachine };
   state1.addTransition(&state2);
   outerStateMachine.setInitialState(&state1);
   outerStateMachine.start();

   a.connect(&state1, &QState::entered, []{ qDebug() << "state1 entered"; });
   a.connect(&state2, &QState::entered, []{ qDebug() << "state2 entered"; });
   a.connect(&state2, &QState::entered, qApp, &QCoreApplication::quit);
   return a.exec();
}

以上是或多或少，自足的测试用例应该如何看待：单个文件，没有绒毛和冗长，从而减损了手头的问题。

为什么在构造函数中使用此指针在QState的子类内部嵌套的QStateMachine会导致外部状态机无法进行转换？

1 个答案: