Cosa succede se definisco un array di dimensioni 0 in C / C ++?

Solo curioso, cosa succede realmente se definisco un array di lunghezza zero int array[0];nel codice? GCC non si lamenta affatto.

Programma di esempio

#include <stdio.h>

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

Una precisazione

In realtà sto cercando di capire se gli array di lunghezza zero inizializzati in questo modo, invece di essere indicati come la lunghezza variabile nei commenti di Darhazer, siano ottimizzati o meno.

Questo perché devo rilasciare un po 'di codice nel jolly, quindi sto cercando di capire se devo gestire i casi in cui SIZEè definito come 0, cosa che accade in alcuni codici con una definizione staticaint array[SIZE];

In realtà sono rimasto sorpreso dal fatto che GCC non si lamenti, il che ha portato alla mia domanda. Dalle risposte che ho ricevuto, credo che la mancanza di un avviso sia in gran parte dovuta al supporto del vecchio codice che non è stato aggiornato con la nuova sintassi [].

Poiché mi chiedevo principalmente l'errore, sto etichettando la risposta di Lundin come corretta (quella di Nawaz era prima, ma non era così completa) - gli altri stavano sottolineando il suo uso effettivo per le strutture imbottite di coda, sebbene pertinente, non è ' t esattamente quello che stavo cercando.

Un array non può avere dimensioni zero.

ISO 9899: 2011 6.7.6.2:

Se l'espressione è un'espressione costante, deve avere un valore maggiore di zero.

Il testo sopra è vero sia per un array semplice (paragrafo 1). Per un VLA (array di lunghezza variabile), il comportamento non è definito se il valore dell'espressione è inferiore o uguale a zero (paragrafo 5). Questo è un testo normativo nello standard C. A un compilatore non è consentito implementarlo in modo diverso.

gcc -std=c99 -pedantic dà un avvertimento per il caso non VLA.

Secondo lo standard, non è consentito.

Tuttavia è stata pratica corrente nei compilatori C trattare queste dichiarazioni come una dichiarazione FAM (flessibile array member ) :

C99 6.7.2.1, §16 : come caso speciale, l'ultimo elemento di una struttura con più di un membro nominato può avere un tipo di array incompleto; questo è chiamato un membro flessibile dell'array.

La sintassi standard di una FAM è:

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

L'idea è che lo si dovrebbe allocare così:

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;
  }
}

Potresti anche usarlo staticamente (estensione gcc):

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

Questo è anche noto come strutture imbottite di coda (questo termine precede la pubblicazione dello standard C99) o hack di struttura (grazie a Joe Wreschnig per averlo sottolineato).

Tuttavia questa sintassi è stata standardizzata (e gli effetti garantiti) solo recentemente in C99. Prima era necessaria una dimensione costante.

• 1 era la strada portatile da percorrere, sebbene fosse piuttosto strana.
• 0 era più bravo a indicare l'intento, ma non era legale per quanto riguarda lo Standard e supportato come estensione da alcuni compilatori (incluso gcc).

La pratica del padding della coda, tuttavia, si basa sul fatto che lo spazio di archiviazione è disponibile (attenzione malloc), quindi non è adatto all'uso dello stack in generale.

In Standard C e C ++, l'array di dimensioni zero non è consentito.

Se stai usando GCC, compilarlo con l' -pedanticopzione. Darà un avvertimento , dicendo:

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

Nel caso di C ++, fornisce un avviso simile.

È totalmente illegale, e lo è sempre stato, ma molti compilatori trascurano di segnalare l'errore. Non sono sicuro del perché tu voglia farlo. L'unico uso che conosco è di innescare un errore di compilazione da un valore booleano:

char someCondition[ condition ];

Se conditionè falso, viene visualizzato un errore di compilazione. Poiché i compilatori lo consentono, tuttavia, ho iniziato a utilizzare:

char someCondition[ 2 * condition - 1 ];

Questo dà una dimensione di 1 o -1 e non ho mai trovato un compilatore che accetterebbe una dimensione di -1.

Aggiungerò che c'è un'intera pagina della documentazione online di gcc su questo argomento.

Alcune citazioni:

Le matrici di lunghezza zero sono consentite in GNU C.

In ISO C90, dovresti dare ai contenuti una lunghezza di 1

e

Le versioni GCC precedenti alla 3.0 consentivano di inizializzare staticamente array di lunghezza zero, come se fossero array flessibili. Oltre a quei casi che erano utili, consentiva anche le inizializzazioni in situazioni che avrebbero danneggiato i dati successivi

così potresti

int arr[0] = { 1 };

e boom :-)

Un altro uso di matrici di lunghezza zero è per creare oggetti di lunghezza variabile (pre-C99). Le matrici di lunghezza zero sono diverse dalle matrici flessibili che hanno [] senza 0.

Citato da gcc doc :

Le matrici di lunghezza zero sono consentite in GNU C. Sono molto utili come ultimo elemento di una struttura che è in realtà un'intestazione per un oggetto di lunghezza variabile:

 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, useresti un membro flessibile dell'array, che è leggermente diverso nella sintassi e nella semantica:

• I membri dell'array flessibile vengono scritti come contenuto [] senza lo 0.
• I membri flessibili dell'array hanno un tipo incompleto e pertanto l'operatore sizeof potrebbe non essere applicato.

Un esempio del mondo reale sono le matrici di lunghezza zero di struct kdbus_itemin kdbus.h (un modulo del kernel Linux).

Le dichiarazioni di array di dimensioni zero all'interno di strutture sarebbero utili se fossero consentite e se la semantica fosse tale che (1) forzerebbero l'allineamento ma non allocerebbero alcuno spazio e (2) indicizzare l'array sarebbe considerato un comportamento definito nella caso in cui il puntatore risultante sarebbe all'interno dello stesso blocco di memoria della struttura. Tale comportamento non è mai stato consentito da alcuno standard C, ma alcuni compilatori più vecchi lo hanno consentito prima che diventasse standard per i compilatori per consentire dichiarazioni di array incomplete con parentesi vuote.

La struttura hack, come comunemente implementata usando un array di dimensioni 1, è pericolosa e non credo che ci sia alcun requisito che i compilatori si astengano dal romperlo. Ad esempio, mi aspetterei che se un compilatore vede int a[1], sarebbe nel suo pieno diritto a considerare a[i]come a[0]. Se qualcuno cerca di aggirare i problemi di allineamento della struttura hack tramite qualcosa del genere

typedef struct {
  dimensione uint32_t;
  uint8_t data [4]; // Usa quattro, per evitare che l'imbottitura riduca le dimensioni della struttura
}

un compilatore potrebbe diventare intelligente e supporre che la dimensione dell'array sia davvero quattro:

; Come è scritto
  foo = myStruct-> data [i];
; Come interpretato (assumendo hardware little-endian)
  foo = ((* (uint32_t *) myStruct-> data) >> (i << 3)) & 0xFF;

Tale ottimizzazione potrebbe essere ragionevole, soprattutto se myStruct->datapotesse essere caricata in un registro nella stessa operazione di myStruct->size. Non so nulla nello standard che proibisca tale ottimizzazione, anche se ovviamente spezzerebbe qualsiasi codice che potrebbe aspettarsi di accedere a cose oltre il quarto elemento.