Grösse Array im Struct

[Reiner W. (reiner_w)]

Steh grad wieder voll auf dem Pointer-Schlauch ;-(

ich zimmer mir grad ein kleines Menü zusammen.
Ich weis nicht, wie die die Größe des Array menuItems[] im struct 
menuItem ermitteln kann.

//menu.h

#ifndef menu_h
#define menu_h

typedef struct menuItem {
    const char *text;
    void (*itemFunction)(void);
    uint8 keep;
} MENUMEMBER_t;


typedef struct menu {
    const char *text;
    MENUMEMBER_t menuItems[];
} MENU_t;


void menuAction (void);

#endif

//menu.c
#include <stdio.h>
#include "menu.h"

MENU_t mainMenu = {
    "Main Menu",       //Menu Name
    {                  //Menu Entries
        {"MenuItem 1", NULL, 0},  //text, function, keep
        {"MenuItem 2", NULL, 1},
        {"MenuItem 3", NULL, 1},
        {"zurueck",    NULL, 0},
    }
};


void menuAction (void) {
    
    printf("keep %d \n",mainMenu.menuItems[0].keep);
    printf("text %s \n",mainMenu.menuItems[0].text);
    printf("keep %d \n",mainMenu.menuItems[1].keep);
    printf("text %s \n",mainMenu.menuItems[1].text);
    printf("keep %d \n",mainMenu.menuItems[2].keep);
    printf("text %s \n",mainMenu.menuItems[2].text);
    printf("keep %d \n",mainMenu.menuItems[3].keep);
    printf("text %s \n",mainMenu.menuItems[3].text);
   
    //size of mainmenu.menuItems
    printf("sizeof(mainMenu %lu \n", sizeof(mainMenu.menuItems) / sizeof(mainMenu.menuItems[0]) ) ;  
    //<-- Error 'sizeof' to an incomplete type MANUMEMBER_t []
       
}

Kann mir einer auf die Sprünge helfen ?
Danke
Reiner

[Karl H. (kbuchegg)]

Reiner W. schrieb:

> ich zimmer mir grad ein kleines Menü zusammen.
> Ich weis nicht, wie die die Größe des Array menuItems[] im struct
> menuItem ermitteln kann.

gar nicht.
Du müsstest dir einen Member in die Struktur machen, in den du bei der 
Initialisierung den Wert reinschreibst.

Ihr erwartet alle zuviel von C. In C ist praktisch nichts irgendwie 
dynamisch. Auch wenn die Strukturdefinition erst mal so aussieht, als ob 
das so wäre

typedef struct menu {
    const char *text;
    MENUMEMBER_t menuItems[];
} MENU_t;

Das ist eine 'Mogelpackung'. Wenn du sowas hast, dann bist du immer auf 
dich alleine gestellt. Der Compiler kann dir da nicht weiter helfen. 
Auch nicht mit einem sizeof. Nur durch Betrachten dieser 
Strukturdefinition kann niemand sagen, wieviel Speicher tatsächlich für 
das Array allokiert wurde. Wenn du die Information brauchst, dann musst 
du selber sie dir in die Struktur reinschreiben.

typedef struct menu {
    const char *text;
    uint8_t     nrItems;
    MENUMEMBER_t menuItems[];
} MENU_t;

wodurch diese ganze dynamische Allokierung

MENU_t mainMenu = {
    "Main Menu",       //Menu Name
     4,                // Anzahl Entries
    {                  //Menu Entries
        {"MenuItem 1", NULL, 0},  //text, function, keep
        {"MenuItem 2", NULL, 1},
        {"MenuItem 3", NULL, 1},
        {"zurueck",    NULL, 0},
    }
};

deutlich an Eleganz verliert, weil du eine Abhängigkeit 2-er Member 
hast.

[Karl H. (kbuchegg)]

https://gcc.gnu.org/onlinedocs/gcc/Zero-Length.html

[Reiner W. (reiner_w)]

Karl Heinz schrieb:
> gar nicht.
> Du müsstest dir einen Member in die Struktur machen, in den du bei der
> Initialisierung den Wert reinschreibst.

Danke, für die schnelle Antwort. Ich hatte es befürchtet;-(
Hab vorher so gelöst:

...
typedef struct menu {
    const char *text;
    MENUMEMBER_t *menuItems[];
} MENU_t;
...

menu.menuItems[0] = &menuItem0;
menu.menuItems[1] = &menuItem1;
menu.menuItems[2] = &menuItem2;
...

Da kann ich dann die Größe ermitteln mit
sizeof(menu.menuItems)/sizeof(menu.menuItems[0]) ermitteln.

Was ist denn sinnvoller ?
(habs grad gesehen, das Problem liegt nicht daran, wie ich das Array am 
struct festmache, sondern daran, dass das Array ohne Länge deklariert 
ist)


Reiner

[Karl H. (kbuchegg)]

Reiner W. schrieb:

> Was ist denn sinnvoller ?

Sinnvoll wäre es zb, wenn du nicht darauf bestehst, alles in einer 
Struktur zu haben

typedef struct menu {
    const char *text;
    uint8_t     nrItems;
    MENUMEMBER_t *menuItems;
} MENU_t;

MENUMEMBER_t mainMenuItems[] =
{
  {"MenuItem 1", NULL, 0},  //text, function, keep
  {"MenuItem 2", NULL, 1},
  {"MenuItem 3", NULL, 1},
  {"zurueck",    NULL, 0},
};

MENU_t mainMenu = {
    "Main Menu",       //Menu Name
     sizeof( mainMenuItems ) / sizeof( *mainMenuItems ),
     mainMenuItems;
};

da kann dir jetzt wieder der Compiler unter die Arm greifen und per 
sizeof die Länge des Arrays ermitteln und in die Struktur eintragen.
Du hast halt einen Pointer mehr im System, mit dem der Zusammenhang der 
Menu Beschreibung zu den Items des Menüs hergestellt wird

  mainMenu
  +-------------------+
  | "Main Menu"       |
  +-------------------+
  | 4                 |
  +-------------------+                +--------------------+
  |        o-------------------------->| MenuItem 1         |
  +-------------------+                | NULL               |
                                       | 0                  |
                                       +--------------------+
                                       | MenuItem 2         |
                                       | NULL               |
                                       | 1                  |
                                       +--------------------+
                                       | MenuItem 3         |
                                       | ....

[Reiner W. (reiner_w)]

Karl Heinz schrieb:
> Du hast halt einen Pointer mehr im System, mit dem der Zusammenhang der
> Menu Beschreibung zu den Items des Menüs hergestellt wird

Danke Karl Heinz für die (wie immer) ausführliche Erklärung!
Hast du eigentlich mal ein Einsteigerbuch geschrieben? Würde ich sofort 
kaufen.

Reiner

[Mark B. (markbrandis)]

Reiner W. schrieb:
> Danke Karl Heinz für die (wie immer) ausführliche Erklärung!
> Hast du eigentlich mal ein Einsteigerbuch geschrieben?

Ja aber hallo! Gleich mal ans Werk machen. :-)

[Karl H. (kbuchegg)]

Ist mir zu viel Stress :-)

[Udo S. (urschmitt)]

Karl Heinz schrieb:
> Ist mir zu viel Stress :-)

Musst doch nur ein paar hundert Threadbeiträge hier zusammenkopieren :-)

Zum Thema: Man könnte auch dafür sorgen, dass das Array der MENUMEMBER_t 
immer mit einem Null Wert abgeschlossen ist.
Dann kann man durchiterieren, bzw die Länge ermitteln wie es strlen() 
bei einem String macht.

[Reiner W. (reiner_w)]

Udo Schmitt schrieb:
> Zum Thema: Man könnte auch dafür sorgen, dass das Array der MENUMEMBER_t
> immer mit einem Null Wert abgeschlossen ist.
> Dann kann man durchiterieren, bzw die Länge ermitteln wie es strlen()
> bei einem String macht.

Stimmt, das hab ich auch schon mal gemacht.
Ich hab jetzt .numberOfItems im Struct zugefügt.
Da ich ja die Menüeinträge sowieso von Hand im Struct anlege, kommt es 
da auch nicht mehr drauf an.

[Karl H. (kbuchegg)]

Udo Schmitt schrieb:

> Zum Thema: Man könnte auch dafür sorgen, dass das Array der MENUMEMBER_t
> immer mit einem Null Wert abgeschlossen ist.

Wobei (hab ich auch gerade erst gelernt) es sich dann um eine gcc 
Extension handeln würde. Im C Standard ist das nicht erlaubt, eine 
Struktur mit einem flexible array member zu initialisieren. d.h. man 
kann natürlich die Struktur schon initialisieren nur eben den flexible 
array member nicht.

[Karl H. (kbuchegg)]

Ich seh das pragmatisch so:

C war von Anfang an darauf ausgelegt, dass alles zur Compile-Time eine 
fixe und feststehende Größe hat. Egal ob das Arrays oder Strukturen 
waren, alles hatte seine Größe und der Compiler konnte die feststellen. 
Hatte man keine fixen Größen, dann musste man über Pointer und alloca 
oder malloc oder ... gehen. Fixe Größe konnte auch sein, dass der 
Compiler Initialisierungen abzählt.

Was ja bis hier her auch noch kein Problem wäre.
Bei Strukturen kommt jetzt noch dazu, dass alle jemals von diesem 
Strukturtyp erzeugten Objekte auch die gleiche Größe haben müssen. Denn 
wenn dem nicht so wäre, dann würde man in Schwierigkeiten kommen, wenn 
man ein Array von diesem Strukturtyp anlegen würde.

Bis dahin war noch alles in Ordnung.

Dann allerdings gab es noch die Fälle, in denen man tatsächlich ein 
Strukturobjekt bauen möchte, welches einen variablen Anteil hat. Man 
behalf sich mit Krücken, in dem man eine struct definierte, welches als 
letzten member ein Array der Länge 1 vorsah (damit dort etwas 
Array-ähnliches steht) allokierte allerdings die Objekte immer per 
malloc, wobei man eine entsprechende Speichergröße errechnete, so dass 
die Datenmenge da rein passt, die man haben wollte. Arrays davon baute 
man einfach nicht und wenn dann waren es Pointer Arrays, deren Elemente 
dynamisch angelegt wurden.
Womit dann auch ganz automatisch der Themenkreis Initialisierung keiner 
war, denn bei dynamischer Allokierung kann man nichts (ausser bei 
calloc) initialisieren.

Ab da war dann das meiste nur noch Kosmetik um diesen 'Hack' zu 
verschönern. Denn an den grundsätzlichen Problem, dass ein Array keine 
Größeninformation mit sich rumträgt, kann man nichts ändern. Da würde 
zuviel Code den Bach runter gehen, wenn man da groß umrührt. Man denke 
nur an die Fälle, die im Zusammenhang mit Parameterpassing an Funktionen 
stehen. Zwischen Arrays und Pointer besteht nun mal in C ein enger 
Zusammenhang.
Also kann sich auch ein Strukturobjekt nicht implizit merken, wie gross 
sein flexible array member ist. Ganz abgesehen davon, dass das das 
Problem der Array Bildung von solchen Strukturen nicht lösen würde. Die 
ist ja immer noch davon abhängig, dass alle Strukturobjekte im Array die 
gleiche Größe haben.