Flexible Array Member initialisieren in C

[Tim T. (tim_taylor)]

Nabend,

ich habe da eine Frage, wie initialisiert man einen flexiblen array 
member zur Compilezeit ohne einen Roman zu schreiben?

Beispiel:

typedef struct
{
    const unsigned Anzahl;
    uint8_t Werte[];
} Muster_t;

Muster_t MusterA = { 3, { 0, 0, 0 } };
Muster_t MusterB = { 1000, { ... } };

In einfachen Fällen wie bei MusterA geht das ja noch, aber wenns mal 
mehr wird wie bei MusterB...
Achja, natürlich könnte ich auch den Speicher per malloc reservieren, 
nullen (bzw. calloc) und die Werte darauf umbiegen, aber das sollte doch 
irgendwie einfacher gehen.
Oder muss ich wirklich ein Script basteln was mir z.B. 1000 Komma 
separierte Nullen als String baut?
Und ja, mir ist schon klar, dass das statische Initialisieren von 
flexiblen array membern eigentlich nicht funktionieren sollte, aber der 
gcc macht da eh eine Ausnahme indem er den flexiblen member zu einem 
statischen macht mit der Größe der Anzahl der Initialisierungswerte.
Was dann natürlich auch eine Möglichkeit wäre, indem man selber für jede 
benötigte Größe des array member ein struct mit dem passenden statischen 
array baut; mit dem Ergebnis, dass man dann eventuell einen ganzen Zoo 
an structs hat.
Oder gibt es da noch eine andere Möglichkeit?

Ok, eine Möglichkeit wäre eventuell das Struct und das Array separat 
anzulegen und nur drauf zu pointern:

typedef struct
{
    const unsigned Anzahl;
    uint8_t *Werte;
} Muster_t;

uint8_t MusterA_Werte[3] = { };
uint8_t MusterB_Werte[1000] = { };

Muster_t MusterA = { sizeof(MusterA_Werte), MusterA_Werte };
Muster_t MusterB = { sizeof(MusterB_Werte), MusterB_Werte };

Aber schöner wird das alles nicht.

[michi (Gast)]

Ein Skript, welches Dir Quellcode generiert? Oha, das klingt ziemlich 
abenteuerlich ;)

Was spricht denn dagegen, dass Du Dir eine Setup-Funktion schreibst, die 
das Array für Dich anhand der übergebenen Größe initialisiert?

Also statt

Muster_t MusterA = { 3, { 0, 0, 0 } };

zum Beispiel so:

Muster_t MusterA = setupMuster(3);

[Tim T. (tim_taylor)]

michi schrieb:
> Ein Skript, welches Dir Quellcode generiert? Oha, das klingt ziemlich
> abenteuerlich ;)

Noch nie eine diskrete Sinustabelle für die Verwendung in einem Array 
generiert oder ähnliches?

> Was spricht denn dagegen, dass Du Dir eine Setup-Funktion schreibst, die
> das Array für Dich anhand der übergebenen Größe initialisiert?
>
> Also statt
>
>

> Muster_t MusterA = { 3, { 0, 0, 0 } };
>

>
> zum Beispiel so:
>
>

> Muster_t MusterA = setupMuster(3);
>

Versuch doch einfach mal, nur so ungefähr, dir die Funktionsweise der 
setupMuster() Funktion zu überlegen...

[MaWin (Gast)]

michi schrieb:
> Was spricht denn dagegen, dass Du Dir eine Setup-Funktion schreibst, die
> das Array für Dich anhand der übergebenen Größe initialisiert?

Dagegen spricht, dass du nicht weißt, was ein flexible array member ist.

[A. S. (Gast)]

Schafft es der GCC, die Nullen wirklich zu Nullen oder kopiert er die?

Zudem ist es unschön, n manuell zu pflegen. Ich würde es separat machen.

Oder nur ein Array allokieren und die Struktur als Ptr darauf legen. Mit 
"init"Funktion, die den ptr zurückgibt,

 



Master_t *MasterPtrCreate(unsigned char *p, unsigned n)
{
Master_t *m = (Master_t *) p;

   m->Anzahl= n-sizeof m->Anzahl;

   return m;

}
...

void x(void)
{
static unsigned char buf[1234];

   Master_t *m=MasterPtrCreate(buf, sizeof buf);
   ...
}

[ein lupenreiner Demokrat (Gast)]

Tim T. schrieb:
> Achja, natürlich könnte ich auch den Speicher per malloc reservieren,
> nullen (bzw. calloc)

anders geht es auch nicht.

und die Länge des Arrays kann man in der Struktur erst ablegen, wenn der 
Speicher für die Struktur (und das Array) reserviert wurde. Somit muss 
man die Größe des Arrays vorher kennen.

[DPA (Gast)]

ungetestet:

Muster_t x = { 1000, {[1000-1]=0} };

[... (Gast)]

> Somit muss man die Größe des Arrays vorher kennen.

"Dank" VLA ist das nicht mehr noetig.
Ich persoenlich wuerde das in Verbindung mit Controllern
aber nicht als Gewinn ansehen.

[ein lupenreiner Demokrat (Gast)]

... schrieb:
> "Dank" VLA

haben nichts mit dem leeren Array am Strukturende zu tun und sind wieder 
abgeschafft.

[Wilhelm M. (wimalopaan)]

Du kannst des mit designated-initializern initialisieren:

typedef struct {
    const unsigned Anzahl;
    uint8_t Werte[];
} Muster_t;

Muster_t MusterA = { 3, { 0} };
Muster_t MusterB = { 1000, {
                         [0] = 1,
                         [1] = 2,
                         [2] = 3,
                         [42] = 42
                     } 
                   };

Aber Achtung: hier gilt dann sizeof(Muster_t) == 2, was nicht der 
wirklichen Objektgröße entspricht.

[DPA (Gast)]

Nö, c23 beschreibt immernoch überall, wie mit VLAs umzugehen ist. Sind 
also noch da.

[Wilhelm M. (wimalopaan)]

DPA schrieb:
> Nö, c23 beschreibt immernoch überall, wie mit VLAs umzugehen ist. Sind
> also noch da.

Ich weiß nicht, auf was Du Dich beziehst. Aber was ich oben geschrieben 
habe, ist kein VLA, sondern ein array of unspecified size.
VLA kann man gar nicht initialisieren, sondern nur die Elemente 
zuweisen.

[DPA (Gast)]

Das bezog sich auf den Gastbeitrag darüber.

[Rolf M. (rmagnus)]

ein lupenreiner Demokrat schrieb:
> ... schrieb:
>> "Dank" VLA
>
> haben nichts mit dem leeren Array am Strukturende zu tun und sind wieder
> abgeschafft.

Nein, nicht abgeschafft, sondern optional.

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

ein lupenreiner Demokrat schrieb:
> und die Länge des Arrays kann man in der Struktur erst ablegen, wenn der
> Speicher für die Struktur (und das Array) reserviert wurde.

$ cat foo.c
struct foo {
        int length;
        char data[];
};

struct foo foobar = { .length = 42, .data = { 3, 10, 11, 0 } };
$ cc -Wall -Wextra -pedantic -O -S foo.c
foo.c:6:45: warning: flexible array initialization is a GNU extension [-Wgnu-flexible-array-initializer]
struct foo foobar = { .length = 42, .data = { 3, 10, 11, 0 } };
                                            ^
foo.c:3:7: note: initialized flexible array member 'data' is here
        char data[];
             ^
1 warning generated.
$ cat foo.s
        .text
        .file   "foo.c"
        .type   foobar,@object                  # @foobar
        .data
        .globl  foobar
        .p2align        2
foobar:
        .long   42                              # 0x2a
        .asciz  "\003\n\013"
        .size   foobar, 8

        .ident  "FreeBSD clang version 13.0.0 ([e-mail]:llvm/llvm-project.git llvmorg-13.0.0-0-gd7b669b3a303)"
        .section        ".note.GNU-stack","",@progbits
        .addrsig

Also ja, man kann ein flexible array member standardgemäß so nicht 
initialisieren, nichtstandardgemäß geht es aber schon.