Konzept der C++-Zustandsmaschine

1. Übersicht über den Zustandsautomaten in C++
2. Vorteile der Zustandsmaschine
3. Zustandsübergang in C++
4. Zustandsmaschinenklasse in C++

Dieses Tutorial informiert uns über das Konzept einer C++-Zustandsmaschine, veranschaulicht, wie wir sie verwenden können, und hebt ihre Vorteile hervor.

Übersicht über den Zustandsautomaten in C++

Um den Zustandsautomaten in C++ zu verstehen, sollten wir zunächst das Konzept eines endlichen Zustandsautomaten kennen.

Ein endlicher Automat ist ein mathematisches Berechnungsmodell, das die Idee erfasst, dass sich ein Computer zu einem bestimmten Zeitpunkt in einem der endlichen Zahlen der Zustände befinden und im Laufe der Zeit zwischen diesen Zuständen wechseln kann.

Eine Zustandsmaschine besteht aus Zuständen, Übergängen und Aktionen. Die Zustände sind die verschiedenen Zustände, in denen sich die FSM befinden kann. Die Übergänge sind die Aktionen, die einen Wechsel von einem Zustand in einen anderen bewirken.

Die Aktionen finden statt, wenn die FSM von einem Zustand in einen anderen wechselt. Die Sprache C++ hat drei Schlüsselwörter, die eine Zustandsmaschine definieren: enum, switch und goto.

Eine Enumeration definiert einen Satz von Konstanten, die jeden möglichen Zustand in der FSM darstellen. Eine switch-Anweisung prüft, welcher Zustand aktiv ist und führt eine entsprechende Aktion aus.

Das Goto wird verwendet, um aus verschachtelten Schleifen zu springen oder Anweisungen zu wechseln, ohne Anweisungen zu unterbrechen oder zurückzugeben.

Vorteile der Zustandsmaschine

Einige der Vorteile sind unten aufgeführt:

• Zustandsautomaten bieten eine elegante Möglichkeit, komplexes Verhalten durch einfache Übergangsregeln auszudrücken.
• Sie eignen sich gut zur Modellierung spezifischer Aspekte realer Systeme wie Ampeln, Aufzüge oder sogar menschlicher Sprachen.
• Zustandsmaschinen zerlegen das Design in eine Reihe von Schritten oder Zuständen im Zustandsmaschinenjargon. Jedes Bundesland ist für eine bestimmte Aufgabe zuständig.
• Im Gegensatz dazu sind Ereignisse die Stimuli, die bewirken, dass sich die Zustandsmaschine zwischen Zuständen bewegt oder übergeht.

Zustandsübergang in C++

Der Zustandsübergang im C++-Zustandsmaschinencode ist ein Prozess, bei dem sich der Zustand des Programms von einem Zustand in einen anderen ändert. Ein Ereignis oder eine Bedingung kann die als Trigger bezeichnete Zustandsänderung auslösen.

Wenn sich ein Zustand ändert, können einige Aktionen ausgeführt werden, z. B. das Ausdrucken von Nachrichten oder das Ändern der Farbe von Objekten auf dem Bildschirm.

Wenn beispielsweise längere Zeit kein Ereignis vorliegt und dann ein Ereignis eintritt, wird der Übergang von Warten auf Standard ausgelöst. Die Programmiersprache C++ bietet eine einfache Möglichkeit, eine Zustandsmaschine mit ihrer switch-Anweisung zu implementieren.

Zustandsmaschinenklasse in C++

Beim Erstellen Ihrer Zustandsmaschine benötigen Sie zwei Basisklassen: StateMachine und EventData. Eine Klasse leitet sich von StateMachine ab, um die Komponenten zu erhalten, die zur Unterstützung von Zustandsänderungen und Ereignisbehandlung erforderlich sind.

Der StateMachine-Header enthält auch mehrere mehrzeilige Präprozessor-Makros, um die Implementierung der Zustandsmaschine zu unterstützen. Die Struktur muss ein Erbe der Basisklasse EventData sein, um den Zustandsfunktionen eindeutige Daten bereitzustellen.

Den Quellcode für die Zustandsmaschine finden wir in den Dateien state_machine.cpp und demo.h.

Beispielcode für state_machine.cpp:

#include <iostream>

#include "demo.h"
using namespace std;
void Execute_State_Machine(void) {
  int 1st_state = 0;
  while (1) {
    char trans_letter;
    cout << "1st state: " << 1st_state << "\n";
    cout << "Enter trans letter: ";
    cin >> trans_letter;
    cin.ignore(100, '\n');
    demo_Entry const* bn = demo_begin();
    demo_Entry const* const p_demo_end = demo_end();
    bool demo_um = false;
    while ((!demo_um) && (bn != p_demo_end)) {
      if (bn->1st_state_id == 1st_state) {
        if (bn->trans_letter == trans_letter) {
          cout << "changing"
               << " from 1st " << 1st_state << ", to 2nd " << bn->pro_state_id
               << "\n";
          1st_state = bn->pro_state_id;
          demo_um = true;
          break;
        }
      }
      ++bn;
    }
    if (!demo_um) {
      cerr << "same\n";
    }
  }
}

Beispielcode für demo.h:

struct demo_x {
  int 1st_state_id;
  char trans_letter;
  int 2nd_state_id;
};
demo_x const* demo_begin(void);
demo_x const* demo_end(void);

Beispielcode für demo.cpp:

#include "demo.h"
static const demo_x demo_m[] = {
    {0, 'T', 1},
    {0, 'U', 2},
    {0, 'V', 3},
};
static const int demo = sizeof(demo_m) / sizeof(demo_m[0]);
Table_Entry const* table_begin(void) { return &demo_m[0]; }
Table_Entry const* table_end(void) { return &demo_m[demo]; }

Klicken Sie hier, um die Funktion des oben genannten Codes zu überprüfen.