Simple Frage zu Tabellen mit Funktionen (Zustände)

[J. W. (ontheway)]

Hi,

bitte zerreißt mich jetzt nicht und schickt mich zu einem Link "C für 
Doofies" oder so. Ich brauche nur einen Tipp, danke. Ich will eigentlich 
nur eine Zustandstabelle durchgehen, die Zustände werden zurückgegeben 
durch Funktionen, also habe ich in der Tabelle Pointer auf Funktionen... 
eventuell trage ich in die Tabelle noch mehr ein, aber wurscht, ich habe 
gerade keinen Plan, wie ich das mache... hier mein Schrott-Code, die 
Idee dürfte klar sein... hierbei besteht die zweite Spalte aus 
Funktionen.


struct t_state_table  {
  state_t state;
  state_t (* fkt) (void);

};

// Vektor fuer state machine

t_state_table state_table[4] = {

  // Zustand Transitionsfunktion
    //----------------------------------------------------------------------
  {
    { S_AUS    , tS_AUS},
    { S_ROT    , tS_ROT},
    { S_GELB  , tS_GELB},
    { S_GRUEN  , tS_GRUEN}
  }

};



void stateMachine()
{
  state =   (*(state_table[state][2]))();

}

[Andreas B. (andreas_b77)]

J. W. schrieb:
> state =   (*(state_table[state][2]))();

Der Index des zweiten Elements ist 1, nicht 2. Funktionszeiger müssen 
nicht explizit derefenziert werden, den * kannst du dir also sparen, 
wenn du willst. Ansonsten sieht das doch gut aus.

[C gcc (Gast)]

Tip:
ein Array aus Strukturen mit 2 Komponenten, ein trägt den Namen "fkt"

[Andreas B. (andreas_b77)]

Au weh, da hab ich nicht richtig aufgepasst. "C gcc" hat natürlich 
recht, den Funktionszeiger bekommt man nicht über einen Array-Index.

[J. W. (ontheway)]

Hey,
ich drehe noch durch, danke schon mal mit dem Wink mit dem Zaunpfahl. 
Das ganze Gemurkse ist eh noch nicht ausgereift, aber das ist mein 
aktueller Code. Funzt nicht. Fehlermeldungen:

Error  11  extra brace group at end of initializer
Error  12  (near initialization for 'state_table[0]')
Error  15  extra brace group at end of initializer
Error  16  (near initialization for 'state_table[0]')

OH man. Die Fehlermeldungen referenzieren auf die Zeilen der Tabelle 
unten mit S_GELB und dann S_GRUEN. Die Pointer auf die Funktionen zeigen 
auf Funktionen, bei denen ich schon zig mal die Klammerebenen geprüft 
habe.

Danke für nen Tipp!

LG
JENS


state_t state = S_AUS;

struct t_state_table  {
  state_t state;
  state_t (* fkt) (void);

} ;



// Tabelle fuer state machine

struct t_state_table state_table[4] = {

  // Zustand Transitionsfunktion
    //---------------------------------
  {
    { S_AUS    , tS_AUS    },
    { S_ROT    , tS_ROT    },
    { S_GELB  , tS_GELB    },
    { S_GRUEN  , tS_GRUEN    }
  }

};



void stateMachine()
{
  state =   (*((state_table[state].fkt)))();

}

[Stefan E. (sternst)]

struct t_state_table state_table[4] = { <<< Klammer um Arrayelemente

  // Zustand Transitionsfunktion
    //---------------------------------
  {                                     <<< noch eine
    { S_AUS    , tS_AUS    },
    { S_ROT    , tS_ROT    },
    { S_GELB  , tS_GELB    },
    { S_GRUEN  , tS_GRUEN    }
  }                                     <<<

};                                      <<<

[J. W. (ontheway)]

Boooah danke, wie doof war das denn schäm

[Yalu X. (yalu) (Moderator)]

Wozu ist überhaupt das Element state in der Struktur? Es wird nirgends
verwendet, und der State zur Selektion der aufzurufenden Funktion steckt
ja implizit schon im Index, mit dem auf das  Array zugegriffen wird.

Reicht nicht auch ein einfaches Array von Funktionspointern wie in
folgendem Beispiel?

state_t state = S_AUS;

state_t (*state_table[])(void) = {
  tS_AUS, tS_ROT, tS_GELB, tS_GRUEN
};

void stateMachine() {
  state = state_table[state]();
}

[J. W. (ontheway)]

Hi Yalu,

absolut richtig! Mir ging es erst einmal um das Prinzip: Zustandsautomat 
über Tabelle mit Zeigern auf Funktionen, die den nächsten Zustand 
zurückgeben. Der Zustand in der Tabelle ist total nutzlos. Ich versuche 
halt ein Konzept zu durchdenken, das einerseits lesbar ist, und 
andererseits auch ausdehnbar. Ich werde versuchen, Automaten zu koppeln, 
und ich möchte mich definitv nicht in einer main() mit if's verirren. 
Klar, für diese bekloppte Ampel ist das Overhead, aber ich möchte halt 
sehr komplexe Automaten abbilden. Konzeptuell schwimme ich noch, aber 
ich denke, wenn ich C++ vermeide (da habe ich echt zuwenig Ahnung, bis 
jetzt), dann kann das ein Ansatz sein. Was meinst Du?

LG
Jens