Anfängerproblem: Funktionszeiger (void, typedef struct)

[Matthias H. (matthias1309)]

Hallo liebe Forum-User!

Ich bin gerade dabei mir selber C beizubringen und experimentiere mit 
Funktionszeigern. Nun stoße ich auf folgendes Problem:

Im nachfolgenden Code habe ich einen "typedef struct" mit dem Namen 
"device_function". Dieser soll eine Liste mit Funktionen enthalten. Als 
Parameter wird ein int-Wert übergeben

#include <stdio.h>
#include <stdlib.h>

typedef struct {
    const char  *text;
    int         zahl;
} param;

typedef struct {
    const char  *description;
    void        (*funct)(int);
    int         parameter;
} device_function;

void mach_was(void* p) {
    int a = *(int*)p;
    printf("Erledige eine Aufgabe: %i\n", a);
}

void mach_noch_was(void* p) {
    int a = *(int*)p;
    printf("Erledige eine zweite Aufgabe: %i\n", a);
}

device_function programm_functions[] = {
    {"Funktion 1", mach_was, 123 },
    {"Funktion 2", mach_noch_was, 123 },
};

static int functions_count = sizeof(programm_functions)/sizeof(programm_functions[0]);  // Anzahl der Einträge

int main()
{
    int i;

    for (i=0;i<functions_count;i++) {
        printf("%s\n",programm_functions[i].description);
        programm_functions[i].funct(&programm_functions[i].parameter);
        printf("\n~~~~~~~~~~~~~~~~~~~~\n");
    }
    return 0;
}

Das Programm funktioniert soweit wunderbar, es kommt die Ausgabe:

Funktion 1
Erledige eine Aufgabe: 123

~~~~~~~~~~~~~~~~~~~~
Funktion 2
Erledige eine zweite Aufgabe: 123

~~~~~~~~~~~~~~~~~~~~

Process returned 0 (0x0)   execution time : 0.027 s
Press any key to continue.

Wenn ich aber jetzt aber anstelle des Integer-Wertes den struct "param" 
verwende, und diesen von void nach param caste, erhalte ich nachfolgende 
Fehlermeldung vom Compiler:

#include <stdio.h>
#include <stdlib.h>

typedef struct {
    const char  *text;
    int         zahl;
} param;

typedef struct {
    const char  *description;
    void        (*funct)(int);
    param       parameter;
} device_function;

void mach_was(void* p) {
    param a = *(param*)p;
    printf("Erledige eine Aufgabe: %i\n", a->zahl);
}

void mach_noch_was(void* p) {
    param a = *(param*)p;
    printf("Erledige eine zweite Aufgabe: %i\n", a->zahl);
}

device_function programm_functions[] = {
    {"Funktion 1", mach_was, {"Test", 123} },
    {"Funktion 2", mach_noch_was, {"Test", 1234} },
};

static int functions_count = sizeof(programm_functions)/sizeof(programm_functions[0]);  // Anzahl der Einträge

int main()
{
    int i;

    for (i=0;i<functions_count;i++) {
        printf("%s\n",programm_functions[i].description);
        programm_functions[i].funct(&programm_functions[i].parameter);
        printf("\n~~~~~~~~~~~~~~~~~~~~\n");
    }
    return 0;
}

||=== Build: Debug in funktionszeiger (compiler: GNU GCC Compiler) ===|
C:\gcc\funktionszeiger\main.c||In function 'mach_was':|
C:\gcc\funktionszeiger\main.c|17|error: invalid type argument of '->' (have 'param')|
C:\gcc\funktionszeiger\main.c||In function 'mach_noch_was':|
C:\gcc\funktionszeiger\main.c|22|error: invalid type argument of '->' (have 'param')|
C:\gcc\funktionszeiger\main.c|26|warning: initialization from incompatible pointer type [enabled by default]|
C:\gcc\funktionszeiger\main.c|26|warning: (near initialization for 'programm_functions[0].funct') [enabled by default]|
C:\gcc\funktionszeiger\main.c|27|warning: initialization from incompatible pointer type [enabled by default]|
C:\gcc\funktionszeiger\main.c|27|warning: (near initialization for 'programm_functions[1].funct') [enabled by default]|
C:\gcc\funktionszeiger\main.c||In function 'main':|
C:\gcc\funktionszeiger\main.c|40|warning: passing argument 1 of 'programm_functions[i].funct' makes integer from pointer without a cast [enabled by default]|
C:\gcc\funktionszeiger\main.c|40|note: expected 'int' but argument is of type 'struct param *'|
||=== Build failed: 2 error(s), 5 warning(s) (0 minute(s), 0 second(s)) ===|

Wo liegt mein Denkfehler im obrigen Programm?

[Peter II (Gast)]

Matthias Haas schrieb:
> Wo liegt mein Denkfehler im obrigen Programm?

void        (*funct)(int);
void mach_noch_was(void* p) {

warum nicht hier auch den richtigen Parameter verwenden? Dann könntest 
du die ganze Casterei sparen.

[Matthias H. (matthias1309)]

Ich möchte eine flexible Struktur schaffen, und der einen Funktion z.B. 
einen Struct übergeben können, der anderen einen String, einer dritten 
Funktion einen Integer-Wert. (union)

[Daniel A. (daniel-a)]

Matthias Haas schrieb:
> void        (*funct)(int);
> void mach_was(void* p)
> device_function programm_functions[] = {
>    {"Funktion 1", mach_was,
Das der implizite cast von void(*)(void*) nach void(*)(int); 
funktioniert ist reines glück!
> param a = *(param*)p;
>  a->zahl
a ist kein pointer! Versuche
param* a = (param*)p;
oder
a.zahl

[Peter II (Gast)]

und warum schreibst du dann hier int?

void        (*funct)(int);

und nicht void*

[Peter II (Gast)]

Matthias Haas schrieb:
> Ich möchte eine flexible Struktur schaffen, und der einen Funktion z.B.
> einen Struct übergeben können, der anderen einen String, einer dritten
> Funktion einen Integer-Wert.

und wie willst du diese werte in deiner Struktur ablegen?

[Karl H. (kbuchegg)]

Matthias Haas schrieb:
> Ich möchte eine flexible Struktur schaffen, und der einen Funktion z.B.
> einen Struct übergeben können, der anderen einen String, einer dritten
> Funktion einen Integer-Wert. (union)

Wenn du sowieso schon so etwas planst

typedef union {
    const char  *text;
    int         zahl;
} funcArg;

dann solltest du das auch durchziehen. Deine Funktionen bekommen dann 
einen Pointer auf eine derartige Union, müssen also der Aufrufkonvention

void func( int argType, funcArg *arg )
{
  ...
}

genügen. Denn sonst schaffst du es ja nicht "beliebige" Argumente (im 
Rahmen dessen, was durch die union möglich ist) in die Funktionen zu 
bringen.

Damit ist dein Funktionspointer aber anders anzulegen und auch die 
Funktionen sind anders auszuführen

(Ich fasse die union und die Typkennzeichnung, welcher Member der union 
gültig ist noch in einer struct zusammen. Damit kann die Funktion 
erkennen, was sie tytsächlich übergeben bekommen hat und entsprechend 
reagieren. Entweder indem sie sich nach dem Datentyp richtet oder indem 
sie mitteilt 'Damit kann ich nichts anfangen')

typedef union {
    const char  *text;
    int         zahl;
} funcArg;

#define TEXT_ARG   0
#define INT_ARG    1

typedef struct
{
  int     argType;
  funcArg arg;
} funcParam;

typedef void (*funcPtr)( funcParam *arg );

typedef struct {
    const char  *description;
    funcPtr     funct;
    param       parameter;
} device_function;

void mach_was(funcParam *p) {
    if( p->argType == INT_ARG )
      printf( "mach_was: Mit Int Arg aufgerufen - %d\n", p->arg.zahl );

    else if( p->argType == TEXT_ARG )
      printf( "mach_was: mit Text Arg aufgerufen - %s\n", p.arg.text );
}

void mach_noch_was(funcParam *p) {
    if( p->argType != INT_ARG )
      printf( "mach_noch_was: Fehler - Funktion mit ungültigem Argumenttyp aufgerufen\n";

    else
      printf( mach_noch_was: %d\n", p->arg.zahl );
}

device_function programm_functions[] = {
    {"Funktion 1", mach_was, { INT_ARG, .zahl = 123 },
    {"Funktion 2", mach_noch_was, { TEXT_ARG, .text = "Test" } },
};

mach um void Zeiger einen großen Bogen wenn du kannst. Mit void Zeigern 
legst du die Typüberwachung des Compilers in letzter Konsequenz einfach 
lahm. Und das ist selten eine gute Idee, wenn es auch anders geht. Dinge 
einfach auf Biegen und Brechen zurecht zu casten, ist meistens eine 
schlechte Lösung - weil DU als Programmierer für die Richtigkeit ganz 
alleine verantwortlich bist. Und das geht öfter in die Hose als einem 
lieb ist. Da ist es schon besser, wenn man auf die Casts verzichten kann 
und der Compiler wenigsten ein bischen über die Schulter schaut und 
kontrolliert.

[W.S. (Gast)]

Matthias Haas schrieb:
> typedef struct {
>     const char  *text;
>     int         zahl;
> } param;

Bringe nach Möglichkeit die Dinge nicht mutwillig durcheinander. Ja, ich 
weiß, daß die C-Freaks am liebsten alles zusammenziehen wollen, aber ein 
sauberer Stil ist das nicht. Mit typedef kannst du einem bestehenden Typ 
einen neuen Namen geben, dazu dient dieses Statement. Zum eigentlichen 
Definieren eines Typs ist das nicht gedacht.

struct TParam
{ const char* Text;
  int Zahl;
}

So sähe das im Grunde aus. Nun kannst du dir aussuchen, ob du es 
anschließend so schreiben willst:

#define param struct TParam

oder so

typedef struct TParam param;

was im Grunde auf dasselbe hinausläuft. Du kannst aber auch schlicht und 
einfach mit TParam weiterarbeiten, ohne das #define und ohne das 
typedef. Es ist nur, daß du dann das struct beim Deklarieren von 
Variablen mit dazuschreiben mußt.

Viele Leute machen den Denkfehler, daß sie glauben, mit typedef 
tatsächlich einen Typ definieren zu können, aber das ist eben falsch und 
führt langfristig nur zu Verständnisproblemen das typedef betreffend.

W.S.

[Johann L. (gjlayde)]

W.S. schrieb:
> Matthias Haas schrieb:
>> typedef struct {
>>     const char  *text;
>>     int         zahl;
>> } param;
>
> Bringe nach Möglichkeit die Dinge nicht mutwillig durcheinander. Ja, ich
> weiß, daß die C-Freaks am liebsten alles zusammenziehen wollen, aber ein
> sauberer Stil ist das nicht. Mit typedef kannst du einem bestehenden Typ
> einen neuen Namen geben, dazu dient dieses Statement. Zum eigentlichen
> Definieren eines Typs ist das nicht gedacht.

Genau dafür ist es gedacht.

Der Typ "struct { const char *text, int zahl }" wird als Typ "param" 
definiert.

> #define param struct TParam

Unnötig und mieser Stil.

> typedef struct TParam param;

struct TParam ist unnötig.

[Karl H. (kbuchegg)]

Johann L. schrieb:

>> typedef struct TParam param;
>
> struct TParam ist unnötig.


... und ich möchte hinzufügen:
und belastet nur den Namensraum mit dem Namen der struct, den (zumindest 
in diesem Fall) keiner braucht.