Die Implementierung einer State Machine in C++, WIE?

typedef std::pair<State,Message> StateMessagePair;
typedef std::map<StateMessagePair,State> StateDiagram;
StateDiagram sd;
//add logic to diagram
...
State currentState = getInitialState();
...
//process message
Message m = getMessage();
StateDiagram::iterator it=sd.find(std::make_pair(currentState,m)));
if (it==sd.end()) exit("incorrect message");
currentState = it->second;

EDIT:
Aufbau der Status-Diagramm ist wie folgt (Beispiel für ein cola-Automat):

StateDiagram.insert(std::make_pair(State::Idle           ,Message::MakeChoice   ),State::WaitingForMoney);
StateDiagram.insert(std::make_pair(State::WaitingForMoney,Message::Cancel       ),State::Idle);
StateDiagram.insert(std::make_pair(State::WaitingForMoney,Message::MoneyEntered ),State::FindCan);
StateDiagram.insert(std::make_pair(State::FindCan        ,Message::CanSentToUser),State::Idle);

Standard-Aktionen umgesetzt werden können, mit einer zweiten Karte, wo der Schlüssel ist nur der Staat, wie dieses:

typedef std::map<State,State> StateDiagramForDefaults;

Statt Druck "falsch-Meldung", die Logik ausführen, eine Suche in der StateDiagramForDefaults.

Wenn Aktionen Hinzugefügt werden muss, um das Zustandsdiagramm, der Wert der Karte sollte ein paar, bestehend aus einer Aktion und einem neuen Staat, wie diese:

typedef std::pair<State,Message> StateMessagePair;
typedef std::pair<State,IAction *> StateActionPair;
typedef std::map<StateMessagePair,StateActionPair> StateDiagram;

Logik baut das Diagramm sollte dann "new" eine Instanz einer Klasse, die IAction implementiert, und diese in der StateDiagram.

Den ausführenden Logik dann nur führt die IAction Umsetzung über eine virtuelle Methode (z.B. execute() oder der ()-operator).

Standard state machine Implementierung Techniken sind:

1. der geschachtelten switch-Anweisung (einige
   bisherigen Beiträge zeigen Beispiele von diesem
   Technik)
2. state-table
3. der GoF design pattern
4. Kombination der oben genannten

Wenn Sie neue, state-machines und die Implementierung in C oder C++, würde ich empfehlen, mein Dr. Dobbs Artikel "Back to Basics", erhältlich bei http://www.ddj.com/184401737 (Sie müssen klicken Sie auf den link Drucken klicken Sie oben, um bequem den text Lesen.)

Keiner von standard-Techniken eignet sich für die hierarchische Zustandsautomaten (z.B. UML, statecharts). Wenn Sie interessiert sind, in der modernen UML-state-machines, würde ich empfehlen, meine 3-Teil Embedded.com Artikel "Ein crash-Kurs in UML-state-machines" (http://www.embedded.com/design/testissue/215801043).

Eine Möglichkeit ist die Verwendung einer Klasse wie dieser (grobe Beispiel-code weiter):

class State
{
  //pass a new Message into the current State
  //current State does (state-specific) processing of
  //the message, and returns a pointer to the new State
  //if there's a state change
  virtual State* getNewState(const Message&) = 0;
};

class ExampleState
{
  virtual State* getNewState(const Message& message)
  {
    switch (message.type)
    {
      case MessageType.Stop:
        //change state to stopped
        return new StoppedState();
    }
    //no state change
    return 0;
  }
};

Auf der Komplikationen ist, ob die Mitgliedstaaten sollten statische Schwungmasse passgenau, oder ob Sie tragen Instanz-Daten und sollten daher newed und gelöscht.

Sehen Implementierung Endlicher Automaten in ein Programm für verschiedene Arten von Gebäude-finite-state-machines.

Den ich verwende, ist auf dieser Basis ein: Maschinen-Objekte.

Scheint es gut optimiert und ist eine Hölle von viel weniger Komplex zu bedienen als Boost-Statechart.

Können Sie die Ragel state machine compiler: http://www.complang.org/ragel/

Ragel kompiliert, die ausführbare endlichen Automaten aus regulären
Sprachen. Ragel Ziele, C, C++ und ASM. Ragel Zustand Maschinen können nicht
nur zu erkennen, byte-Sequenzen als regulären Ausdruck Maschinen tun, aber
auch das ausführen von code an beliebigen Punkten in der Anerkennung einer
reguläre Sprache. Code einbetten erfolgt mittels inline-Operatoren, die
tun nicht stören die reguläre Sprache syntax.

Die core-Sprache besteht aus standard-Operatoren für reguläre Ausdrücke
(wie union, Verkettung und Kleene-Stern) und Aktion einbetten
Betreiber. Der Benutzer reguläre Ausdrücke kompiliert werden, um eine
deterministische state-Maschine und die eingebettete Aktionen verbunden sind
mit den übergängen von der Maschine. Das Verständnis der formalen
Beziehung zwischen regulären Ausdrücken und deterministische endliche
Automaten ist der Schlüssel zu verwenden Ragel effektiv.

Ragel bietet auch Operatoren, mit denen Sie die Kontrolle über alle nicht-Determinismus
Sie erstellen, konstruieren, Scanner und bauen Stand-Maschinen mit einem
statechart-Modell. Es ist auch möglich, Einfluss auf die Ausführung eines
Zustand Maschine in einer eingebetteten Aktion durch einen Sprung oder Aufruf zu
andere Teile der Maschine, oder der Aufarbeitung Eingang.

Ragel bietet eine sehr flexible Schnittstelle zum host-Sprache, die
versucht minimalen Einschränkungen auf, wie der generierte code ist
in die Anwendung integriert. Der generierte code hat keine
Abhängigkeiten.

Ragel code sieht wie folgt aus:

action dgt      { printf("DGT: %c\n", fc); }
action dec      { printf("DEC: .\n"); }
action exp      { printf("EXP: %c\n", fc); }
action exp_sign { printf("SGN: %c\n", fc); }
action number   { /*NUMBER*/ }

number = (
    [0-9]+ $dgt ( '.' @dec [0-9]+ $dgt )?
    ( [eE] ( [+\-] $exp_sign )? [0-9]+ $exp )?
) %number;

main := ( number '\n' )*;

.. und es kompiliert:

st0:
    if ( ++p == pe )
        goto out0;
    if ( 48 <= (*p) && (*p) <= 57 )
        goto tr0;
    goto st_err;
tr0:
    { printf("DGT: %c\n", (*p)); }
st1:
    if ( ++p == pe )
        goto out1;
    switch ( (*p) ) {
        case 10: goto tr5;
        case 46: goto tr7;
        case 69: goto st4;
        case 101: goto st4;
    }
    if ( 48 <= (*p) && (*p) <= 57 )
        goto tr0;
    goto st_err;