C Verständnissfrage Pointer (ja wieder mal ;-) )

[Andreas B. (bitverdreher)]

Hallo,
hier habe ich einen Codeschnipsel, den ich selbst mal irgendwo (Hier im 
Forum? Leider finde ich die Stelle nicht mehr) kopiert und angepasst 
habe.

typedef struct {
   void (*func);                      // Pointer to the function
   char text[5];                      // command of function
} command_t

// command array
const command_t commands[] PROGMEM= {
   { PBlockEEprom, "BL" },
   { EPB, "ERB" },
   { EWB, "EWB" },
 .. hier folgen noch weitere
};

int8_t execute (const char *text) {
uint16_t i;
   const command_t * cmd = commands;
   for (i=0; i < sizeof(commands) / sizeof(command_t); i++) {
      if (strcasecmp_P (text, cmd->text)) {
        cmd++;
        continue;
      }
      int16_t (*func)(int16_t); // found <-- Was macht das??? 
      func = (int16_t(*)(int16_t)) pgm_read_word (& cmd->func); // get pointer
      return func(1);
   }
   if (DEBUG) UsartPuts ("Syntax Error\n");
   return 0;

Die Funktion Execute ruft mir die entsprechende Funktion auf, die als 
String übergeben wird. Das funktioniert auch so weit wunderbar.
Was mir hier aber unklar ist, habe ich oben markiert.

Jetzt wollte ich etwas ähnliches machen. Es sollen Zeilen aus einer 
Konfigurationsdatei eingelesen werden und entsprechende Variablen 
gesetzt werden. (Format Variable=Wert, für jede Variable eine neue 
Zeile)

Dazu habe ich den Code wie folgt angepaßt:

typedef struct {
  void (*varpointer);               // Pointer to the variable
  char text[10];                    // keyword
} keyword_t;

// default values
uint8 Vcc_min = 237;
uint8 SleepTime = 0;

// keyword array for the configuration file (pointer to the variables)
const keyword_t keywords[] PROGMEM= {
   { &SleepTime, "SLEEPTIME" },
   { &Vcc_min, "VCC_MIN" }
};       


relevanter Auschnitt aus der betreffenden Funktion:

   char filechar;
   uint8_t i;    
   const keyword_t * key = keywords;
   char sline[MAX_BUFFER];    
   char* vline;

          while (filechar = FAT_ReadLine(file, sline, MAX_BUFFER)) // read until EOL
          {             
            for (i=0; i < sizeof(keywords) / sizeof(keyword_t); i++) {
               if (strcasecmp_P (sline, key->text)) {
               key++;
               continue;
               }
               int16_t (*varpointer)(int16_t); // found
               varpointer = (int16_t(*)(int16_t)) pgm_read_word (& key->varpointer); // get pointer

               // replace EOL to 0x00 (use as string)               
               vline = strchr(sline, 0x0D);
               *vline = 0x00;
               // seek the "=" in the line, vline is now a string with the value after '='               
               vline++ = strchr(sline, 0x3D);
               
               // set the variable of the key table to the readed value
               *varpointer = atoi(vline);

            }

varpointer sollte doch jetzt ein Pointer auf meine gesuchte Variable 
sein, *varpointer somit der Inhalt.
Beim Kompilieren bekomme ich hier aber den Fehler:
error: lvalue required as left operand of assignment

Wo ist hier mein  Denkfehler?

Gruß
Andreas

[Karl H. (kbuchegg)]

Du wirfst hier kunterbunt Datenzeiger und Zeiger auf Funktionen 
durcheinander.

Lern in deinem C-Buch über normale Pointer und mach erst mal einen Bogen 
um Funktionspointer.

Und so wie das aussieht, bist du gut beraten erst mal keine void Pointer 
zu benutzen. So wie das aussieht, gibt es dazu auch keinen Grund.

typedef struct {
  uint8_t* varpointer;              // Pointer to the variable
  char     text[10];                // keyword
} keyword_t;

uint8 Vcc_min = 237;
uint8 SleepTime = 0;

const keyword_t keywords[] PROGMEM= {
   { &SleepTime, "SLEEPTIME" },
   { &Vcc_min, "VCC_MIN" }
};

....

               uint8_t* varpointer = (uint8_t*)pgm_read_word (&key->varpointer);

               // replace EOL to 0x00 (use as string)               
               vline = strchr(sline, 0x0D);
               *vline = 0x00;
               // seek the "=" in the line, vline is now a string with the value after '='               
               vline++ = strchr(sline, '=');
               
               // set the variable of the key table to the readed value
               *varpointer = atoi(vline);
....

[Andreas B. (bitverdreher)]

Hallo Karl-Heinz,
daß das im Original Funktionszeiger sind, ist mir schon klar. Die Basics 
von Pointern habe ich schon verstanden. Mir fehlt halt die Übung in C.
Es sollen jetzt aber Zeiger auf meine Variablen sein, die ich vorher 
deklariert habe.

Was macht denn jetzt genau int16_t (*func)(int16_t)?
Dabei wird scheibar auch die Variable func deklariert. Aber verstehen 
tue ich diese Zeile nicht.

Gruß
Andreas

[Karl H. (kbuchegg)]

Das hier

      int16_t (*func)(int16_t);

sind Zeiger auf Funktionen. Im Original werden keine Werte 
abgespeichert, sondern abhängig vom Text Funktionen aufgerufen. Das ist 
was völlig anderes. Das ist schon etwas aus der gehobeneren Kategorie 
der Programmierung.
func ist ein Zeiger auf eine Funktion und diese Funktion will einen 
int16_t als Argument haben und liefert als Returnwert einen int16_t.



Kannst du mir erklären, warum du hier

               vline++ = strchr(sline, 0x3D);

0x3D schreibst? Warum nicht einfach

               vline++ = strchr(sline, '=');

Wäre das zu einfach? Zu Lesbar? Zu wenige Möglichkeiten Fehler zu 
machen? Nach dem Motto: "Es war schwer zu schreiben, also soll es auch 
schwer zu lesen sein!"
Im übrigen hat die ganze Anweisung undefiniertes Verhalten.

               vline = strchr(sline, '=');
               vline++;

Und abfragen, ob '=' überhaupt gefunden wurde, sollte man dann auch 
noch.

               vline = strchr(sline, '=');
               if( vline != NULL )
               { 
                 vline++;
                 *varpointer = atoi(vline);
               }

Das EOL entfernen kannst du dir hingegen sparen. atoi hört sowieso mit 
der Konvertierung auf, sobald es auf das erste Zeichen stösst, welches 
nicht mehr zu einer Zahl gehören kann. Solange dein String sauber 
aufgebaut ist, mit einem \0 Zeichen als letztes Zeichen (welches ein 
String sowieso immer haben sollte, denn sonst ist es kein String), kann 
dir da also gar nichts passieren. Aber wenn du schon ersetzen willst, 
dann bitte auch immer prüfen, ob ein gesuchtes Zeichen auch wirklich 
gefunden wurde! Alles andere ist nämlich ein Spiel mit dem Feuer

               // replace EOL to 0x00 (use as string)               
               vline = strchr(sline, 0x0D);
               if( vline != NULL )
                 *vline = 0x00;

Die ganze Schleife kann man im übrigen auch ohne von hinten durch die 
Brust ins Auge programmieren. Zum einen kann man durch umdrehen der 
strcasecmp_P Abfrage den continue wegbringen, zum anderen könntest du 
dich mit dir einigen, ob du jetzt über einen Index zugreifst, oder doch 
einen Pointer weiterzählen willst.

            for (i=0; i < sizeof(keywords) / sizeof(keyword_t); i++) {
               if (strcasecmp_P(sline, keywords[i].text) == 0) {
                 // gefunden!
               }
            }

beides gleichzeitig ist irgendwie doppelt gemoppelt.

[Andreas B. (bitverdreher)]

Hallo Karl-Heinz,
Danke für die Tips. Ich gehe das jetzt mal alles durch. Ich habe vor 
einigen Jahren mal etwas in C programmiert. Mir fehlt da einfach die 
Übung.
Das Ende des Strings habe ich nicht beachtet, da der String ja aus einer 
Datei ausgelesen wird. Spätestes beim EOF ist ja das Ende des Strings. 
Aber Du hast recht, ich werde das etwas sauberer programmieren.

Kannst Du diese Zeile (int16_t (*func)(int16_t);) mal etwas erläutern?
Daß *func ein Pointer auf eine Funktion ist, habe ich schon verstanden. 
Das ist im Datentyp der Struktur ja so definiert. Ist das nur eine 
Deklaration für func als Funktionspointer? Wenn ja, warum definiert man 
das nicht am Anfang der Funktion selbst?

Gruß
Andreas

[Jörg W. (dl8dtl) (Moderator)]

Andreas B. schrieb:
> Kannst Du diese Zeile (int16_t (*func)(int16_t);) mal etwas erläutern?

% cdecl
Type `help' or `?' for help
explain unsigned short (*fp)(unsigned short)
declare fp as pointer to function (unsigned short) returning unsigned short

(Ich habe mal "fp" statt "func" benutzt, da "func" bei cdecl ein
Schlüsselwort ist.  Die Zeile mit "explain" ist meine Eingabe, die mit
"declare" die Ausgabe von cdecl.)

[Andreas B. (bitverdreher)]

Hallo Jörg,
Danke Dir!
Also doch einen Delaration. Es hatte mich nur irritiert, daß diese 
Deklaration im Ursprungscode mitten im Code stand.

Gruß
Andreas

[Rufus Τ. F. (rufus)]

Andreas B. schrieb:
> Es hatte mich nur irritiert, daß diese
> Deklaration im Ursprungscode mitten im Code stand.

In C99 sind Variablendefinitionen mitten im Code zulässig (und in C++ 
sowieso).

Am Anfang eines Blocks (eines in {} stehenden Abschnittes, also auch in 
einem if-Statement oder in einer for-Schleife o.ä.) sind sie das in C 
aber schon immer, auch wenn das hier nicht der Fall ist. o.g. Code lässt 
sich also nur von einem C99-toleranten Compiler übersetzen.

Ob man Variablen so definieren möchte, ist in erster Linie eine 
stilistische Frage; es gibt Leute, die der Ansicht sind, Variablen 
sollten so spät wie möglich definiert werden, und es gibt Leute, die der 
Ansicht sind, daß alle in einer Funktion verwendeten Variablen an deren 
Anfang definiert werden sollten. Letzteres hilft beim Quelltextlesen den 
Stackbedarf einzuschätzen.