Übergabe Funktionspointer und Struct

Martin J. schrieb:
> Ich hoffe mein Problem ist so einigermaßen klar geworden.

Sorry, mir leider nicht.

Das fctptr im obigen Beispiel ist was? Eine Funktion von einem fremden 
Treiber, den du nur übernimmst?

1) Origanisiere die Daten für die verschiedenen Treiber so, dass sie 
alle das gleiche Layout haben.  Evtl. ist dann Info in den Daten die ein 
Treiber nicht braucht.

oder

2) Lege die Strukturen in eine Union.  Jede Struktur und die Union haben 
als erstes Element ein Datum, dass die Daten identifiziert:
 

1

typedef union

2

{

3

    int id;

4

5

    struct

6

    {

7

        int id;

8

        ...

9

    } foo;

10

    struct

11

    {

12

        int id;

13

        ...

14

    } bar;

15

    ...

16

} data_t;

17

18

void f (data_t *data)

19

{

20

    if (data->id == DATA_FOO)

21

    {

22

        // use data->foo

23

    }

24

}

oder

3) Nimm einen void* und caste zu dem Datenzeiger der gebraucht wird 
(nicht so toll).

Ich glaube, mir dämmert dein Problem.

Die struct soll sich von Treiber zu Treiber irgendwie unterscheiden, 
trotzdem willst du sie über dieselbe Parameterliste bringen, und 
letztlich landet sie pber den Funktionspointer als Parameter bei der 
richtigen Funktion?

Dann wäre evtl. eine union der richtige Weg:
Du schreibst für jeden Treiber die struct, machst von allen eine union 
und übergibst jeweils den Funktionszeiger und einen Zeiger auf die 
union.
Die Funktion nimmt sich dann aus der union das, was sie braucht.

Programmierer schrieb:
> Das ist der Anwendungsfall für C++

ja, aber Masochismus ist verbreitet, das muß man akzeoptieren :-)

Nehmen wir an, Du hast folgende "Treiberfunktionen":

1

void init_driver1(void);

2

void init_driver2(void);

3

void exit_driver1(void);

4

void exit_driver2(void);

5

void draw_line_driver1(int x, int y, int x2, int y2);

6

void draw_line_driver2(int x, int y, int x2, int y2);

Dann bastelst Du dir ein struct, daß die Funktionszeiger aufnehmen kann:

1

struct driver_entry

2

{

3

    void (*init)();

4

    void (*exit)();

5

    void (*draw_line)(int x, int y, int x1, int x2);

6

    /* ... */

7

};

...und initialisierst ein Array aus solchen structs, über das Du 
zugreifen kannst:

1

static struct driver_entry drivers[] =

2

{

3

    { 

4

        init_driver1,

5

        exit_driver1,

6

        draw_line_driver1,

7

    },

8

    {

9

        init_driver2,

10

        exit_driver2,

11

        draw_line_driver2,

12

    }

13

};

14

static int num_drivers = sizeof(drivers) / sizeof(driver_entry);

Jetzt kannst Du nach Belieben damit rumhantieren:

1

int main(void)

2

{

3

    struct driver_entry *my_driver = &drivers[1]; /* nehmen wir mal den */

4

5

    my_driver->init();

6

    my_driver->draw_line(0, 0, 10, 10);

7

    my_driver->exit();

8

}

Sooo viel schöner ist das in C++ auch nicht. Und wenn die 
unterschiedlichen "Treiber" unterschiedliche Funktionen brauchen, muß 
man halt noch eine union dazwischen hängen.

Programmierer schrieb:
> Warum wollen immer alle um jeden Preis C++ vermeiden, auch
> wenn es perfekt geeignet ist?

Ich hätte das (möglicherweise) tatsächlich mit C++ gemacht. 
Möglicherweise sogar obwohl Libraries mit C++ manchmal überhaupt 
keinen Spaß machen...

Der Fragesteller hat aber offensichtlich mit C schon seine Probleme, 
warum ihm also 'nen Daimler aufschwatzen, wenn er eigentlich ein Fahrrad 
wollte? ;)

Klaus Wachtler schrieb:
> Ich glaube, mir dämmert dein Problem.

Genau :-)


Allen schon mal vielen Dank für die Ideen. Ja man könnte das auch schön
elegant in C++ realisieren, doch dann müsste ich meine ganzen anderen
Bibliotheken ändern und darauf habe ich grad keine Lust. ;-)
Am Ende ist die Verwendung der Structs für die Variable
SPI-Schnittstelle der Treiber ja auch nur ein Pseudo C++, so dass man
weiter C verwenden kann.

Ich hatte nur gedacht, dass es für solche Fälle noch andere
Möglichkeiten in C gibt. Immerhin wurden auch sehr Komplexe Programe in
C geschrieben, die eine ähnliche Flexibilität erfordern.

Danke.

... dann machen wir die vtable eben vollends fertig:

1

extern void text_init(void);

2

extern void text_exit(void);

3

extern void text_print(int x, int y, char *txt);

4

extern void graf_init(void);

5

extern void graf_exit(void);

6

extern void draw_line(int x, int y, int x1, int y1);

7

8

enum driver_type

9

{

10

    GRAPHICS_DRIVER,

11

    TEXT_DRIVER

12

};

13

14

struct graphics_driver

15

{

16

    void (*init)();

17

    void (*exit)();

18

    void (*draw_line)(int x, int y, int x1, int x2);

19

    /* ... */

20

};

21

22

struct char_driver

23

{

24

    void (*init)();

25

    void (*exit)();

26

    void (*print)(int x, int y, char *txt);

27

};

28

29

static struct graphics_driver driver1 =

30

{

31

    .init = graf_init,

32

    .exit = graf_exit,

33

    .draw_line = draw_line,

34

};

35

36

static struct char_driver driver2 =

37

{

38

    .init = text_init,

39

    .exit = text_exit,

40

    .print = text_print,

41

};

42

43

struct driver

44

{

45

    enum driver_type type;

46

    union

47

    {

48

        struct graphics_driver *gd;

49

        struct char_driver *cd;

50

    };

51

};

52

53

struct driver drivers[] =

54

{

55

    { .type = GRAPHICS_DRIVER, { .gd = &driver1 }},

56

    { .type = TEXT_DRIVER, { .cd = &driver2 }},

57

};

Nicht unbedingt schön, aber tun tut's ;)