====== State Machine ======

Immer wieder kommen //<wrap :en>Statemachines</wrap>// in Programmen vor. Die Implementierung einer solchen kann bzw. muss unterschiedlich ausfallen, je nach dem wie groß eine solche //<wrap :en>Statemachine</wrap>// werden kann.


===== while / switch =====

Ein erster kleiner Entwurf könnte wie folgt aussehen:

<tabbox C/C++>
<code c>
while(1)
{
    switch(state)
    {
    case state1:
        // do something
        break;
    case state2:
        // do different thing
        // no break
    case state3:
        // do other things
        break;
    default:
        // Error: invalid state
        break;
    }
}
</code>

<tabbox Python>

</tabbox>

Vom Ansatz her ist das eine sehr überschaubare //<wrap :en>Statemachine</wrap>//. Die Variable ''state'' stellt den aktuellen Status dar und in der ''switch''-Anweisung wird in den passenden Zweig die Arbeit fortgesetzt. Sind jedoch die Anweisungen sehr umfangreich und sehr viele Status zu verwalten, kann die Übersicht schnell verloren gehen. Dabei wird es schwer zu unterscheiden zwischen dem "Funktionskörper" der für den jeweiligen Status ausgeführt werden soll und der Bestimmung für den Folgezustand. Der nächste Zustand wird durch setzten von ''state'' im noch aktuellen Zustand durchgeführt.


===== Funktionen und Fkt. Pointer =====

Bei Funktionen wird jeder Zustand (oben ''case'' genannt) in einer Funktion abgelegt - sozusagen der "Funktionskörper" des Zustandes. Mit einem Pointer auf Funktionen wird auf die aktuelle Funktion referenziert. Ein mühsames Auswerten, welcher Zweig der <wrap :en>Staemachine</wrap> angesprungen werden muss, wie in der ''switch''-Anweisung, bleibt erspart. Bei vielen Zuständen kann das sehr viel schneller gehen. Der Folgezustand wird durch zuweisen der Adresse der neuen Funktion (Zustand) an den Pointer durchgeführt.


===== Objekte und Objektreferenz =====

Hier wird ähnlich zu [[#Funktionen und Fkt. Pointer]] ein Pointer auf ein Objekt gesetzt.

Der Objekttyp für den Zustand (//<wrap :en>state</wrap>//) könnte Methoden definieren wie ''onEnter()'', ''onLeave()''.

Der Objekttyp für den Zustandsautomaten (//<wrap :en>Statemachine</wrap>//) könnte als Klassenvariable den Zeiger auf den Zustand führen. Des weiteren könnte mit mit einer Register-Funktion der Übergang von Zustand zu Zustand definiert werden, dabei könnte eine Transfer-Funktion (als //<wrap :en>Callback</wrap>//) registriert werden.

Bei einem Übergang werden folgende Schritte ausgeführt:
  - Zustand(alt).onLeave()
  - Transfer-Funktion
  - Zustand(neu).onEnter()
  - Referenz zeigt nun auf Zustand(neu)


  UrStammVater                // Dient als "Vorlage" für 'StammVater'-Klassen/Objekte.
  |
  +-- StammVater1             // Erste Statemachine, könnte als Klassenvariable den Zeiger auf den aktuellen 'StateX_Y' für diese Statemachine enthalten.
  |   |
  |   +-- State1_1            // erter 'State' in dieser Statemachine
  |   +-- State1_2
  :   :
  |   +-- State1_n            // letzter 'State' in dieser Statemachine
  |
  +-- StammVater2             // eine zweite unabhängige Statemachine
      |
      +-- State2_1
      +-- State2_2
       :
      +-- State2_n




{{tag>Python Konzept}}