C: Alternative zu switch case "mit Lücken"

[Case-Switcher (Gast)]

Hallo,

ich schreibe gerade einen "Übersetzer" zwischen zwei Netzen, der mir die 
aus dem einen Netz empfangene (binäre) Daten in etwas übersetzt, was ich 
in das andere weiter schicken kann (ASCII).
Das erste Byte eines jeden Datenblocks ist eine Zahl als "Kommando".
Dadurch ist automatisch die Länge des danach gesendeten Wertes, die Art 
des Wertes, die Funktion zur Umrechnung und die Funktion zum 
Zusammenbasteln des übersetzten Strings festgelegt.

Ich könnte also einfach eine Struktur definieren:

struct comm {
       uint8_t len;
       uint8_t *val;
       f_ptr calculate_val;
       f_ptr output_string;
};
struct comm command[10];
...

Dann könnte ich bei jedem empfangenen cmd_byte einfach prüfen, ob die 
Payload danach = command[cmd_byte].len lang ist, mit der Funktion 
command[cmd_byte].calculate_val() den Wert berechnen, in *val speichern 
und mit der Funktion output_string weitersenden.
Das wäre doch elegant.

Leider sind die cmd_bytes nicht aufeinander folgende Zahlen, sondern 08, 
21, 27, ...

Nun kann ich dem natürlich abhelfen mit

switch (cmd_byte) {
     case 07:
         cmd_idx=0;
         break;
     case 21:
         cmd_idx=1;
         break;
....
}

aber das ist irgendwie weit weniger elegant. Dann kann ich auch gleich 
die Funktionsaufrufe und Berechnungen noch mit in die case Blöcke 
packen, und es wird hässlich zu lesen.
Gibt es eine Alternative?

[Vincent H. (vinci)]

Look-up table?

[M.K. B. (mkbit)]

Eine Lookuptabelle in der man das Kommando sucht und der Index ist dann 
der cmd_idx.

[abc.def (Gast)]

Case-Switcher schrieb:


void foo(void) {
> switch (cmd_byte) {
>      case 07:
>          fkt_07();
>          break;
>      case 21:
>          fkt_21();
>          break;
> }
}//foo

Der Compiler macht daraus in Assembler eine Leiter von Vergleichen und 
Sprüngen JMP (nicht CALL), gleich zur fkt_07 (undsoweiter). fkt_07 endet 
mit einem RET, was gleich ans Ende der Funktion }//foo führt.
Warum sollte das nicht übersichtlich sein? (wenn man aussagefähige Namen 
vergibt)
Erst in einer Tabelle nach dem idx suchen halte ich für 
unübersichtlicher, zumal die Tabelle von 08 bis 20 "nichts" enthält.

[A. S. (Gast)]

M.K. B. schrieb:
> Eine Lookuptabelle in der man das Kommando sucht und der Index ist dann
> der cmd_idx.

Aber nur, wenn man an jedem Byte spart. Sonst macht man halt die 
komplette Tabelle und sucht nicht.

[Wolfgang (Gast)]

abc.def schrieb:
> Erst in einer Tabelle nach dem idx suchen halte ich für
> unübersichtlicher, zumal die Tabelle von 08 bis 20 "nichts" enthält.

Da sucht man auch nicht, sondern adressiert mit dem Kommandobyte.

Es kommt drauf an, ob Effizienz, Codegröße, Speicherbedarf, 
Schreibaufwand beim Programmieren, Lesbarkeit des Quellcodes oder 
sonstwas das Kriterium für Eleganz ist.

[Case-Switcher (Gast)]

M.K. B. schrieb:
> Eine Lookuptabelle in der man das Kommando sucht und der Index ist dann
> der cmd_idx.
Das heißt, die struct wird zu:

struct comm {
       uint8_t cmd;
       uint8_t len;
       uint8_t *val;
       f_ptr calculate_val;
       f_ptr output_string;
};
struct comm command[10];

// und dann das empfangene cmd_byte zuordnen:

for (i=0; i<max; i++) {
       if (command[i].cmd == cmd_byte)
           cmd_idx = i;
}

OK. Das sieht etwas hübscher aus.

Macht das einen Unterschied in der Ausführungsgeschwindigkeit oder im 
RAM-Verbrauch?
Wo liegen eigentlich die Konstanten der switch... case Anweisung? Im 
Flash oder im RAM? Ich nehme an, die kommen nur für die Ausführung des 
Codeblocks der switch... case Anweisung ins RAM, oder?
Die struct wäre im RAM. Dann würde 10*sizeof(cmd) zusätzlich verbraucht.

Wolfgang schrieb:
> Es kommt drauf an, ob Effizienz, Codegröße, Speicherbedarf,
> Schreibaufwand beim Programmieren, Lesbarkeit des Quellcodes oder
> sonstwas das Kriterium für Eleganz ist.
In Netz 1 kursieren etwa 100 verschiedene Befehle, von denen mich aber 
nur 10 bis 15 interessieren. Bei 15 ist eine komplette Tabelle mit 255 
Werten, so dass ich cmd_byte als Index nehmen kann, Verschwendung auf 
einem kleinen µC mit 1k RAM und 16k Flash, finde ich.

Ausführungsgeschwindigkeit ist sicher auch ein Kriterium, aber nicht 
sooo kritisch. Ich glaube nicht, dass ich eingangsseitig so schnell 
einen Überlauf bekomme, weil ich die Daten nicht übersetzt bekomme.

Aber Schreibaufwand/Lesbarkeit wäre mir wichtig. Wenn's unübersichtlich 
wird oder wenn zusammengehörende Daten an verschiedenen Stellen 
definiert werden, bin ich selbst derjenige, der das pflegen muss.

[Fipo (Gast)]

Mach doch ein bindump und kuck nach?

[(prx) A. K. (prx)]

Welches Schema ein Compiler bei der der Umsetzung von switch Statements 
abhängig von den konkreten case Werte implementiert, ist nicht trivial 
vorherzusagen, und kann sich bei einer Änderung der Werte oder der 
Compilerversion jederzeit ändern.

[S. R. (svenska)]

Warum nicht einfach eine Funktion:

int8_t get_payload_len(uint8_t cmd) {
  switch(cmd) {
  case 0x07: return(4);
  case 0x28: return(28);
  /* usw */
  default: return(-1);
  }
}

Sowas finde ich zumindest recht gut lesbar und es lässt sich einfach 
erweitern. Setzt allerdings voraus, dass die Payload-Länge nicht allzu 
umständlich zu berechnen ist.

Der Compiler wird das schon halbwegs effizient umsetzen, abhängig von 
den Parametern (wenn du auf Größe optimierst, eher nicht mit einer 
vollen 256 Byte-Tabelle).

Oder du implementierst die gesamte Verarbeitung direkt so:

void handle_cmd(uint8_t *buf, uint8_t len) {
  switch(buf[0]) {
  case 0x07: handle_first_cmd(buf, len); break;
  case 0x28: handle_second_cmd(buf, len); break;
  default: panic("unknown cmd %d", buf[0]); break;
  }
}

Das lässt sich ebenfalls wunderbar erweitern und ergibt eine 
übersichtliche Struktur im Code. Ob das sinnvoll ist, hängt vom 
Befehlssatz ab, im schlimmsten Fall kriegst du viel Boilerplate und 
Redundanz rein.

Wenn du den Code aber aus einer anderen Beschreibung (z.B. Excel, XML 
oder sowas) generieren lässt, ist das aus meiner Sicht die Struktur der 
Wahl.

[Axel S. (a-za-z0-9)]

Case-Switcher schrieb:

> ich schreibe gerade einen "Übersetzer" zwischen zwei Netzen, der mir die
> aus dem einen Netz empfangene (binäre) Daten in etwas übersetzt, was ich
> in das andere weiter schicken kann (ASCII).
> Das erste Byte eines jeden Datenblocks ist eine Zahl als "Kommando".
> Dadurch ist automatisch die Länge des danach gesendeten Wertes, die Art
> des Wertes, die Funktion zur Umrechnung und die Funktion zum
> Zusammenbasteln des übersetzten Strings festgelegt.
>
> Ich könnte also einfach eine Struktur definieren:
>

struct comm {
>        uint8_t len;
>        uint8_t *val;
>        f_ptr calculate_val;
>        f_ptr output_string;
> };
>

...
> Leider sind die cmd_bytes nicht aufeinander folgende Zahlen, sondern 08,
> 21, 27, ...
>
> Nun kann ich dem natürlich abhelfen mit
>

switch (cmd_byte) {
>      case 07:
>          cmd_idx=0;
>          break;
>      case 21:
>          cmd_idx=1;
>          break;
> ....
> }
>

> aber das ist irgendwie weit weniger elegant.

Finde ich nicht. Im Prinzip hast du die zwei Möglichkeiten der Lösung 
erkannt. Du kannst die Logik entweder als Programmcode oder als 
Datenstruktur aufschreiben.

Programmcode läuft auf ein switch() Statement hinaus. Und ja, dann würde 
man die notwendigen Aktionen direkt in den case: Blöcken unterbringen. 
Wobei man identischen Code natürlich trotzdem in Funktionen auslagern 
und von dort aus aufrufen kann.

Die Alternative besteht aus einem Array (oder einer Liste oder einer C++ 
std::map) von structs, die notwendige Daten und Funktionszeiger 
enthalten. In dem Fall ist der Code selber eher trivial - anhand des 
ersten Bytes deiner Nachricht die richtige struct finden und dann die 
Funktion per Zeiger aufrufen. Wenn deine Indizes nichtkontinuierlich 
sind, ist ein assoziatives Array (z.B. std::map) der kanonische 
Container. Eine Liste müßtest du durchsuchen. Ein Array mit dem 
Kommandobyte als Index würde Platz verschwenden.

Von der Nachvollziehbarkeit halte ich die switch() Variante für schöner. 
Denn im zweiten Fall müßte man immer erstmal die Datenstruktur 
konsultieren, um den Namen der referenzierten Action-Funktion zu 
erfahren. Das kann man zwar vereinfachen, z.B. indem man sprechende 
Namen für die Funktionen verwendet. Aber irgendwann wird sich irgendwer 
nicht mehr daran halten and dann ist Essig.

Bei der Variante mit switch() kann man diesbezüglich nichts falsch 
machen. Man kann da sogar noch eine Optimierung anbringen, indem man die 
häufigsten Fälle an den Anfang zieht.

[Case-Switcher (Gast)]

Erst einmal vielen Dank an alle!

Die "eierlegende Wollmilchsau" gibt's also mal wieder nicht.
Ich kann entweder mit dem array of struct arbeiten und muss dann das 
empfangene cmd_byte einem Index cmd_idx zuordnen, entweder durch

for (i=0; i<max; i++) {
       if (command[i].cmd == cmd_byte)
           cmd_idx = i;
}

oder durch

switch (cmd_byte) {
     case 07:
         cmd_idx=0;
         break;
     case 21:
         cmd_idx=1;
         break;
....
}

Oder ich packe wie S. R. (svenska) gleich (inline) Wrapper-Funktionen in 
das switch() statement.

Axel S. schrieb:
> Eine Liste müßtest du durchsuchen. Ein Array mit dem
> Kommandobyte als Index würde Platz verschwenden.
Ein array of struct wie oben würde hier sogar das RAM sprengen (1kb).
Also bleibt mit einer for loop zu suchen oder eben switch().

Ich finde die struct eigentlich ganz praktisch, da man da alle 
Informationen an einem Ort im Überblick hat.
Schade, dass man in den Array eben nicht direkt hinein springen kann.
Für ein assoziatives Array müsste ich plain C verlassen...

[Ralf G. (ralg)]

Falls es aufeinanderfolgende Codenummern gibt und dann der 'cmd_idx' 
nur hochgezählt wird, könnte man noch etwas vereinfachen:

switch (cmd_byte)
{
     case 07:
         cmd_idx = 0;
         break;
     case 21: case 22: case 23:
         cmd_idx = cmd_byte - 20;
         break;
....
}

[A. S. (Gast)]

Case-Switcher schrieb:
> oder durch
>

> switch (cmd_byte) {
>      case 07:
>          cmd_idx=0;
>          break;
>      case 21:
>          cmd_idx=1;
>          break;
> ....
> }
>

> Oder ich packe wie S. R. (svenska) gleich (inline) Wrapper-Funktionen in
> das switch() statement

Die Darstellung ist aber einfach Müll, egal wer da irgendwelche 
Kodierungsrichtlienen erstellt. Sowas gehört so, und nicht anders:

switch (cmd_byte) {
     case 0x07: cmd_idx=0;  break;
     case 0x21: cmd_idx=1;  break;
....
}

Dann ist es so klar les- und änderbar wie jede Tabelle

[Axel S. (a-za-z0-9)]

Case-Switcher schrieb:
> Ich finde die struct eigentlich ganz praktisch, da man da alle
> Informationen an einem Ort im Überblick hat.

Außer den Code selber. Denn von den Funktionen sieht man in der struct 
nur den Namen. Eben deswegen finde ich die Variante mit switch() 
besser. Der Code steht in unmittelbarer Nähe des Tokens (der Wert nach 
dem case: Schlüsselwort).

Wenn man die Funktionsweise verstehen will, ist es trivial im Editor 
nach dem Token zu suchen und dann an praktisch der gleichen Stelle den 
zugehörigen Code zu finden.