Ist die Verwendung flexibler Array-Mitglieder in C eine schlechte Praxis?

Ich habe kürzlich gelesen, dass die Verwendung flexibler Array-Mitglieder in C eine schlechte Software-Engineering-Praxis war. Diese Aussage wurde jedoch nicht durch Argumente gestützt. Ist das eine akzeptierte Tatsache?

(Flexible Array-Mitglieder sind ein in C99 eingeführtes C-Feature, mit dem man das letzte Element als Array unspezifizierter Größe deklarieren kann. Zum Beispiel: )

struct header {
    size_t len;
    unsigned char data[];
};

Es ist eine anerkannte “Tatsache”, dass die Verwendung von goto eine schlechte Software-Engineering-Praxis ist. Das macht es nicht wahr. Es gibt Zeiten, in denen goto nützlich ist, insbesondere beim Aufräumen und beim Portieren von Assembler.

Flexible Array-Mitglieder scheinen mir spontan einen Hauptzweck zu haben, der Legacy-Datenformate wie Fenstervorlagenformate auf RiscOS abbildet. Sie wären dafür vor etwa 15 Jahren äußerst nützlich gewesen, und ich bin sicher, dass es immer noch Leute da draußen gibt, die sich mit solchen Dingen befassen, die sie nützlich finden würden.

Wenn die Verwendung flexibler Array-Mitglieder eine schlechte Praxis ist, dann schlage ich vor, dass wir alle dies den Autoren der C99-Spezifikation mitteilen. Ich vermute, dass sie eine andere Antwort haben könnten.

Nein, verwenden flexible Array-Mitglieder in C ist keine schlechte Praxis.

Diese Sprachfunktion wurde zuerst in ISO C99, 6.7.2.1 (16) standardisiert. In der folgenden Überarbeitung, ISO C11, ist es in Abschnitt 6.7.2.1 (18) spezifiziert.

Sie können sie wie folgt verwenden:

struct Header {
    size_t d;
    long v[];
};
typedef struct Header Header;
size_t n = 123; // can dynamically change during program execution
// ...
Header *h = malloc(sizeof(Header) + sizeof(long[n]));
h->n = n;

Alternativ können Sie auch so zuweisen:

Header *h = malloc(sizeof *h + n * sizeof h->v[0]);

Beachten Sie, dass sizeof(Header) enthält eventuelle Füllbytes, daher ist die folgende Zuordnung falsch und kann zu einem Pufferüberlauf führen:

Header *h = malloc(sizeof(size_t) + sizeof(long[n])); // invalid!

Eine Struktur mit flexiblen Array-Mitgliedern reduziert die Anzahl der Zuweisungen dafür um 1/2, dh statt 2 Zuweisungen für ein Strukturobjekt benötigen Sie nur 1. Das bedeutet weniger Aufwand und weniger Speicherverbrauch durch Speicherallokator-Buchhaltungsaufwand. Außerdem spart man sich den Speicherplatz für einen zusätzlichen Zeiger. Wenn Sie also eine große Anzahl solcher Struct-Instanzen zuweisen müssen, verbessern Sie die Laufzeit und den Speicherverbrauch Ihres Programms messbar (um einen konstanten Faktor).

Im Gegensatz dazu kann die Verwendung nicht standardisierter Konstrukte für flexible Array-Mitglieder, die zu undefiniertem Verhalten führen (z. B. wie in long v[0]; oder long v[1];) ist offensichtlich schlechte Praxis. Daher sollte dies wie jedes undefinierte Verhalten vermieden werden.

Seit der Veröffentlichung von ISO C99 im Jahr 1999, also vor mehr als 20 Jahren, ist das Streben nach ISO C89-Kompatibilität ein schwaches Argument.

BITTE LESEN SIE SORGFÄLTIG DIE KOMMENTARE UNTER DIESER ANTWORT

Da die C-Standardisierung voranschreitet, gibt es keinen Grund für die Verwendung [1] mehr.

Der Grund, warum ich es nicht tun würde, ist, dass es sich nicht lohnt, Ihren Code an C99 zu binden, nur um diese Funktion zu verwenden.

Der Punkt ist, dass Sie immer die folgende Redewendung verwenden können:

struct header {
  size_t len;
  unsigned char data[1];
};

Das ist voll tragbar. Dann können Sie die 1 berücksichtigen, wenn Sie den Speicher für n Elemente im Array zuweisen data :

ptr = malloc(sizeof(struct header) + (n-1));

Wenn Sie aus irgendeinem anderen Grund bereits C99 als Voraussetzung zum Erstellen Ihres Codes haben oder auf einen bestimmten Compiler abzielen, sehe ich keinen Schaden.

Du meintest…

struct header
{
 size_t len;
 unsigned char data[];
}; 

In C ist das eine gängige Redewendung. Ich denke, viele Compiler akzeptieren auch:

  unsigned char data[0];

Ja, es ist gefährlich, aber andererseits ist es wirklich nicht gefährlicher als normale C-Arrays – dh SEHR gefährlich 😉 . Verwenden Sie es mit Vorsicht und nur in Situationen, in denen Sie wirklich ein Array unbekannter Größe benötigen. Stellen Sie sicher, dass Sie den Speicher korrekt mallocieren und freigeben, indem Sie Folgendes verwenden:

  foo = malloc(sizeof(header) + N * sizeof(data[0]));
  foo->len = N;

Eine Alternative besteht darin, Daten nur als Zeiger auf die Elemente zu verwenden. Sie können die Daten dann je nach Bedarf in der richtigen Größe neu zuordnen ().

  struct header
    {
     size_t len;
     unsigned char *data;
    }; 

Wenn Sie nach C++ fragen würden, wäre beides natürlich eine schlechte Übung. Dann würden Sie normalerweise stattdessen STL-Vektoren verwenden.

Ich habe so etwas gesehen: von C-Schnittstelle und Implementierung.

  struct header {
    size_t len;
    unsigned char *data;
};

   struct header *p;
   p = malloc(sizeof(*p) + len + 1 );
   p->data = (unsigned char*) (p + 1 );  // memory after p is mine! 

Hinweis: Daten müssen nicht das letzte Element sein.

Als Randnotiz sollte für die C89-Kompatibilität eine solche Struktur wie folgt zugewiesen werden:

struct header *my_header
  = malloc(offsetof(struct header, data) + n * sizeof my_header->data);

Oder mit Makros:

#define FLEXIBLE_SIZE SIZE_MAX /* or whatever maximum length for an array */
#define SIZEOF_FLEXIBLE(type, member, length) \
  ( offsetof(type, member) + (length) * sizeof ((type *)0)->member[0] )

struct header {
  size_t len;
  unsigned char data[FLEXIBLE_SIZE];
};

...

size_t n = 123;
struct header *my_header = malloc(SIZEOF_FLEXIBLE(struct header, data, n));

Das Setzen von FLEXIBLE_SIZE auf SIZE_MAX stellt fast sicher, dass dies fehlschlägt:

struct header *my_header = malloc(sizeof *my_header);

Es gibt einige Nachteile in Bezug darauf, wie Strukturen manchmal verwendet werden, und es kann gefährlich sein, wenn Sie die Auswirkungen nicht durchdenken.

Für Ihr Beispiel, wenn Sie eine Funktion starten:

void test(void) {
  struct header;
  char *p = &header.data[0];

  ...
}

Dann sind die Ergebnisse undefiniert (da den Daten nie Speicherplatz zugewiesen wurde). Dies ist etwas, das Ihnen normalerweise bewusst ist, aber es gibt Fälle, in denen C-Programmierer wahrscheinlich daran gewöhnt sind, Wertesemantik für Strukturen verwenden zu können, die auf verschiedene andere Arten zusammenbricht.

Wenn ich zum Beispiel definiere:

struct header2 {
  int len;
  char data[MAXLEN]; /* MAXLEN some appropriately large number */
}

Dann kann ich einfach per Zuweisung zwei Instanzen kopieren, also:

struct header2 inst1 = inst2;

Oder wenn sie als Zeiger definiert sind:

struct header2 *inst1 = *inst2;

Dies funktioniert jedoch nicht für flexible Array-Mitglieder, da deren Inhalt nicht kopiert wird. Was Sie wollen, ist, die Größe der Struktur dynamisch zu mallocieren und über das Array zu kopieren memcpy oder gleichwertig.

struct header3 {
  int len;
  char data[]; /* flexible array member */
}

Ebenso schreibt man eine Funktion, die a akzeptiert struct header3 wird nicht funktionieren, da Argumente in Funktionsaufrufen wiederum nach Wert kopiert werden und Sie daher wahrscheinlich nur das erste Element Ihres flexiblen Array-Mitglieds erhalten.

 void not_good ( struct header3 ) ;

Dies macht die Verwendung nicht zu einer schlechten Idee, aber Sie müssen daran denken, diese Strukturen immer dynamisch zuzuweisen und sie nur als Zeiger weiterzugeben.

 void good ( struct header3 * ) ;