So initialisieren Sie eine Struktur mit einem flexiblen Array-Mitglied

Ich habe folgende Struktur

typedef struct _person {
    int age;
    char sex;
    char name[];
}person;

Ich habe eine grundlegende Internetsuche (aber erfolglos) durchgeführt, um eine Instanz zu erstellen und eine Struktur mit einem flexiblen Array-Mitglied ohne Verwendung zu initialisieren malloc().

Zum Beispiel: für normale Strukturen wie

struct a {
    int age; 
    int sex;
};

Wir können eine Instanz von erstellen struct a und initialisieren Sie es wie

struct a p1 = {10, 'm'};

Aber für Strukturen mit flexiblem Array darin (wie _person wie oben erwähnt), wie können wir eine Instanz erstellen und initialisieren, wie wir es normalerweise tun structures?

Ist es überhaupt möglich? Wenn ja, wie übergeben wir bei der Initialisierung die Array-Größe und den eigentlich zu initialisierenden Wert?

(oder)

Stimmt es, dass die einzige Möglichkeit, eine Struktur mit flexiblem Array zu erstellen, die Verwendung von ist malloc() wie in der C99-Spezifikation erwähnt – 6.7.2.1 Structure and union specifiers - point #17?!

Nein, flexible Arrays müssen immer manuell zugewiesen werden. Aber Sie können verwenden calloc zum Initialisieren des flexiblen Teils und ein zusammengesetztes Literal zum Initialisieren des festen Teils. Ich würde das in eine Zuordnung packen inline funktionieren so:

typedef struct person {
  unsigned age;
  char sex;
  size_t size;
  char name[];
} person;

inline
person* alloc_person(int a, char s, size_t n) {
  person * ret = calloc(sizeof(person) + n, 1);
  if (ret) memcpy(ret,
                  &(person const){ .age = a, .sex = s, .size = n},
                  sizeof(person));
  return ret;
}

Beachten Sie, dass die Prüfung, ob die Zuweisung erfolgreich war, dem Anrufer bleibt.

Wenn Sie keine benötigen size Feld, wie ich es hier eingefügt habe, würde sogar ein Makro ausreichen. Nur dass es nicht möglich wäre, die Rücksendung zu überprüfen calloc bevor Sie das tun memcpy. Unter allen Systemen, die ich bisher programmiert habe, bricht dies relativ schön ab. Generell denke ich das Rückkehr von malloc ist von untergeordneter Bedeutungaber die Meinungen zu diesem Thema gehen weit auseinander.

Dies könnte (in diesem speziellen Fall) dem Optimierer vielleicht mehr Möglichkeiten geben, den Code in die Umgebung zu integrieren:

#define ALLOC_PERSON(A,  S,  N)                                 \
((person*)memcpy(calloc(sizeof(person) + (N), 1),               \
                 &(person const){ .age = (A), .sex = (S) },     \
                 sizeof(person)))

Bearbeiten: Der Fall, dass dies besser sein könnte als die Funktion ist, wenn A und S sind Kompilierzeitkonstanten. In diesem Fall das zusammengesetzte Literal, da es so ist const qualifiziert, könnte statisch zugewiesen werden und seine Initialisierung könnte zur Kompilierzeit erfolgen. Wenn außerdem mehrere Zuweisungen mit denselben Werten im Code erscheinen würden, wäre es dem Compiler erlaubt, nur eine einzige Kopie dieses zusammengesetzten Literals zu realisieren.

Es gibt einige Tricks, die Sie anwenden können. Es hängt von Ihrer speziellen Anwendung ab.

Wenn Sie eine einzelne Variable initialisieren möchten, können Sie eine Struktur in der richtigen Größe definieren:

   struct  {
        int age;
        char sex;
        char name[sizeof("THE_NAME")];
    } your_variable = { 55, 'M', "THE_NAME" };

Das Problem ist, dass Sie Pointer-Casting verwenden müssen, um die Variable als “Person” zu interpretieren (z. B. “*(person *)(&your_variable)”. Aber Sie können eine enthaltende Vereinigung verwenden, um dies zu vermeiden:

union {
 struct { ..., char name[sizeof("THE_NAME")]; } x;
 person p;
} your_var = { 55, 'M', "THE_NAME" };

Ihre_var.p ist also vom Typ “Person”. Sie können auch ein Makro verwenden, um Ihren Initialisierer zu definieren, sodass Sie die Zeichenfolge nur einmal schreiben müssen:

#define INIVAR(x_, age_, sex_ ,s_) \
   union {\
     struct { ..., char name[sizeof(s_)]; } x;\
     person p;\
    } x_ = { (age_), (sex_), (s_) }

INIVAR(your_var, 55, 'M', "THE NAME");

Ein weiteres Problem ist, dass dieser Trick nicht dazu geeignet ist, ein Array von “Personen” zu erstellen. Das Problem bei Arrays ist, dass alle Elemente die gleiche Größe haben müssen. In diesem Fall ist es sicherer, a zu verwenden const char * anstelle einer char[]. Oder nutzen Sie die dynamische Zuordnung 😉

Ein Strukturtyp mit einem flexiblen Arraymitglied kann so behandelt werden, als ob das flexible Arraymitglied weggelassen würde, sodass Sie die Struktur wie folgt initialisieren können.

person p = { 10, 'x' };

Es sind jedoch keine Mitglieder des flexiblen Arrays zugeordnet, und jeder Versuch, auf ein Mitglied des flexiblen Arrays zuzugreifen oder einen Zeiger auf eines hinter seinem Ende zu bilden, ist ungültig. Die einzige Möglichkeit, eine Instanz einer Struktur mit einem flexiblen Array-Member zu erstellen, das tatsächlich Elemente in diesem Array enthält, besteht darin, ihm dynamisch Speicher zuzuweisen, z. B. mit malloc.