Was passiert, wenn ich in C / C ++ ein Array der Größe 0 definiere?

Nur neugierig, was passiert eigentlich, wenn ich ein Array mit der Länge Null int array[0];im Code definiere? GCC beschwert sich überhaupt nicht.

Beispielprogramm

#include <stdio.h>

int main() {
    int arr[0];
    return 0;
}

Klärung

Ich versuche tatsächlich herauszufinden, ob Arrays mit der Länge Null, die auf diese Weise initialisiert wurden, optimiert sind oder nicht, anstatt wie in Darhazers Kommentaren auf die variable Länge hingewiesen zu werden.

Dies liegt daran, dass ich Code in die Wildnis freigeben muss, also versuche ich herauszufinden, ob ich Fälle behandeln muss, in denen der SIZEdefiniert ist 0, was in einem Code mit einem statisch definierten Code der Fall istint array[SIZE];

Ich war tatsächlich überrascht, dass sich GCC nicht beschwert, was zu meiner Frage führte. Aufgrund der Antworten, die ich erhalten habe, glaube ich, dass das Fehlen einer Warnung hauptsächlich auf die Unterstützung von altem Code zurückzuführen ist, der nicht mit der neuen [] -Syntax aktualisiert wurde.

Da ich mich hauptsächlich über den Fehler gewundert habe, markiere ich Lundins Antwort als richtig (Nawaz war die erste, aber nicht so vollständig) - die anderen wiesen darauf hin, dass die tatsächliche Verwendung für schwanzgepolsterte Strukturen zwar relevant ist, aber nicht. genau das, wonach ich gesucht habe.

Ein Array kann keine Größe von Null haben.

ISO 9899: 2011 6.7.6.2:

Wenn der Ausdruck ein konstanter Ausdruck ist, muss er einen Wert größer als Null haben.

Der obige Text gilt sowohl für ein einfaches Array (Absatz 1). Bei einem VLA (Array mit variabler Länge) ist das Verhalten undefiniert, wenn der Wert des Ausdrucks kleiner oder gleich Null ist (Absatz 5). Dies ist normativer Text im C-Standard. Ein Compiler darf es nicht anders implementieren.

gcc -std=c99 -pedantic gibt eine Warnung für den Nicht-VLA-Fall aus.

Gemäß dem Standard ist es nicht erlaubt.

In C-Compilern ist es jedoch derzeit üblich, diese Deklarationen als FAM- Deklaration (Flexible Array Member ) zu behandeln :

C99 6.7.2.1, §16 : Als Sonderfall kann das letzte Element einer Struktur mit mehr als einem benannten Element einen unvollständigen Array-Typ haben; Dies wird als flexibles Array-Mitglied bezeichnet.

Die Standardsyntax eines FAM lautet:

struct Array {
  size_t size;
  int content[];
};

Die Idee ist, dass Sie es dann so zuweisen würden:

void foo(size_t x) {
  Array* array = malloc(sizeof(size_t) + x * sizeof(int));

  array->size = x;
  for (size_t i = 0; i != x; ++i) {
    array->content[i] = 0;
  }
}

Sie können es auch statisch verwenden (gcc-Erweiterung):

Array a = { 3, { 1, 2, 3 } };

Dies wird auch als schwanzgepolsterte Strukturen (dieser Begriff stammt aus der Zeit vor der Veröffentlichung des C99-Standards) oder als Struktur-Hack (danke an Joe Wreschnig für den Hinweis) bezeichnet.

Diese Syntax wurde jedoch erst kürzlich in C99 standardisiert (und die Effekte garantiert). Vorher war eine konstante Größe notwendig.

• 1 war der tragbare Weg, obwohl es ziemlich seltsam war.
• 0 war besser in der Anzeige von Absichten, aber in Bezug auf den Standard nicht legal und wurde von einigen Compilern (einschließlich gcc) als Erweiterung unterstützt.

Die Praxis der Schwanzpolsterung beruht jedoch auf der Tatsache, dass Speicher verfügbar ist (vorsichtig malloc) und daher im Allgemeinen nicht für die Stapelverwendung geeignet ist .

In Standard C und C ++ ist ein Array mit der Größe Null nicht zulässig.

Wenn Sie GCC verwenden, kompilieren Sie es mit der -pedanticOption. Es wird eine Warnung geben und sagen:

zero.c:3:6: warning: ISO C forbids zero-size array 'a' [-pedantic]

Im Fall von C ++ gibt es eine ähnliche Warnung.

Es ist völlig illegal und war es schon immer, aber viele Compiler vernachlässigen es, den Fehler zu signalisieren. Ich bin mir nicht sicher, warum du das machen willst. Die einzige mir bekannte Verwendung besteht darin, einen Kompilierungszeitfehler von einem Booleschen Wert auszulösen:

char someCondition[ condition ];

Wenn dies conditionfalsch ist, wird ein Fehler bei der Kompilierung angezeigt. Da Compiler dies jedoch zulassen, habe ich Folgendes verwendet:

char someCondition[ 2 * condition - 1 ];

Dies ergibt eine Größe von 1 oder -1, und ich habe noch nie einen Compiler gefunden, der eine Größe von -1 akzeptiert.

Ich werde hinzufügen, dass es zu diesem Argument eine ganze Seite der Online-Dokumentation von gcc gibt.

Einige Zitate:

Arrays mit der Länge Null sind in GNU C zulässig.

In ISO C90 müssten Sie dem Inhalt eine Länge von 1 geben

und

Mit GCC-Versionen vor 3.0 konnten Arrays mit der Länge Null statisch initialisiert werden, als wären sie flexible Arrays. Zusätzlich zu den nützlichen Fällen wurden Initialisierungen in Situationen zugelassen, die spätere Daten beschädigen würden

so könntest du

int arr[0] = { 1 };

und boom :-)

Eine andere Verwendung von Arrays mit der Länge Null besteht darin, Objekte mit variabler Länge (vor C99) zu erstellen. Nulllängen - Arrays sind verschieden von flexiblen Arrays denen [] ohne 0.

Zitiert aus gcc doc :

Arrays mit der Länge Null sind in GNU C zulässig. Sie sind sehr nützlich als letztes Element einer Struktur, die wirklich ein Header für ein Objekt mit variabler Länge ist:

 struct line {
   int length;
   char contents[0];
 };
 
 struct line *thisline = (struct line *)
   malloc (sizeof (struct line) + this_length);
 thisline->length = this_length;

In ISO C99 würden Sie ein flexibles Array-Element verwenden, das sich in Syntax und Semantik geringfügig unterscheidet:

• Flexible Array-Mitglieder werden als Inhalt [] ohne die 0 geschrieben.
• Flexible Array-Elemente haben einen unvollständigen Typ, sodass der Operator sizeof möglicherweise nicht angewendet wird.

Ein Beispiel aus der Praxis sind Arrays mit der Länge Null struct kdbus_itemin kdbus.h (einem Linux-Kernelmodul).

Array-Deklarationen mit der Größe Null innerhalb von Strukturen wären nützlich, wenn sie zulässig wären und wenn die Semantik so wäre, dass (1) sie die Ausrichtung erzwingen, aber ansonsten keinen Platz zuweisen würden, und (2) die Indizierung des Arrays als definiertes Verhalten in der Struktur betrachtet würde Fall, in dem sich der resultierende Zeiger im selben Speicherblock wie die Struktur befindet. Ein solches Verhalten wurde von keinem C-Standard zugelassen, aber einige ältere Compiler erlaubten es, bevor es zum Standard für Compiler wurde, unvollständige Array-Deklarationen mit leeren Klammern zuzulassen.

Der Struktur-Hack, wie er üblicherweise mit einem Array der Größe 1 implementiert wird, ist zweifelhaft und ich glaube nicht, dass Compiler es unterlassen müssen, ihn zu brechen. Zum Beispiel würde ich erwarten, dass ein Compiler, wenn er dies sieht int a[1], in seinem Recht liegt, dies a[i]als zu betrachten a[0]. Wenn jemand versucht, die Ausrichtungsprobleme des Struktur-Hacks über so etwas zu umgehen

typedef struct {
  uint32_t Größe;
  uint8_t Daten [4]; // Verwenden Sie vier, um zu vermeiden, dass das Auffüllen die Größe der Struktur beeinträchtigt
}}

Ein Compiler könnte klug werden und davon ausgehen, dass die Array-Größe tatsächlich vier beträgt:

;; Wie geschrieben
  foo = myStruct-> data [i];
;; Wie interpretiert (unter der Annahme von Little-Endian-Hardware)
  foo = ((* (uint32_t *) myStruct-> data) >> (i << 3)) & 0xFF;

Eine solche Optimierung könnte sinnvoll sein, insbesondere wenn myStruct->datasie in derselben Operation wie in ein Register geladen werden könnte myStruct->size. Ich weiß nichts in dem Standard, was eine solche Optimierung verbieten würde, obwohl es natürlich jeden Code brechen würde, der erwarten könnte, auf Dinge über das vierte Element hinaus zuzugreifen.