¿Qué sucede si defino una matriz de tamaño 0 en C / C ++?

Por curiosidad, ¿qué sucede realmente si defino una matriz de longitud cero int array[0];en el código? GCC no se queja en absoluto.

Programa de muestra

#include <stdio.h>

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

Aclaración

Realmente estoy tratando de averiguar si las matrices de longitud cero inicializadas de esta manera, en lugar de señalarlas como la longitud variable en los comentarios de Darhazer, están optimizadas o no.

Esto se debe a que tengo que liberar algo de código en la naturaleza, así que estoy tratando de averiguar si tengo que manejar los casos en los que SIZEse define como 0, lo que sucede en algunos códigos con una definición estáticaint array[SIZE];

De hecho, me sorprendió que GCC no se quejara, lo que llevó a mi pregunta. De las respuestas que he recibido, creo que la falta de una advertencia se debe en gran medida al soporte de código antiguo que no se ha actualizado con la nueva sintaxis [].

Debido a que principalmente me preguntaba sobre el error, estoy etiquetando la respuesta de Lundin como correcta (la de Nawaz fue la primera, pero no fue tan completa); los otros señalaron su uso real para estructuras acolchadas con cola, aunque relevante, no es Es exactamente lo que estaba buscando.

Una matriz no puede tener tamaño cero.

ISO 9899: 2011 6.7.6.2:

Si la expresión es una expresión constante, tendrá un valor mayor que cero.

El texto anterior es verdadero tanto para una matriz simple (párrafo 1). Para un VLA (matriz de longitud variable), el comportamiento no está definido si el valor de la expresión es menor o igual a cero (párrafo 5). Este es un texto normativo en el estándar C. Un compilador no puede implementarlo de manera diferente.

gcc -std=c99 -pedantic da una advertencia para el caso no VLA.

Según el estándar, no está permitido.

Sin embargo, ha sido una práctica actual en los compiladores de C tratar esas declaraciones como una declaración de miembro de matriz flexible ( FAM ) :

C99 6.7.2.1, §16 : Como caso especial, el último elemento de una estructura con más de un miembro nombrado puede tener un tipo de matriz incompleto; Esto se llama un miembro de matriz flexible.

La sintaxis estándar de una FAM es:

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

La idea es que luego lo asigne así:

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

También puede usarlo estáticamente (extensión gcc):

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

Esto también se conoce como estructuras con relleno de cola (este término es anterior a la publicación del estándar C99) o estructura pirateada (gracias a Joe Wreschnig por señalarlo).

Sin embargo, esta sintaxis fue estandarizada (y los efectos garantizados) solo recientemente en C99. Antes era necesario un tamaño constante.

• 1 era el camino portátil a seguir, aunque era bastante extraño.
• 0 fue mejor para indicar la intención, pero no es legal en lo que respecta a la Norma y algunos compiladores la respaldaron como una extensión (incluido gcc).

Sin embargo, la práctica de relleno de cola se basa en el hecho de que el almacenamiento está disponible (cuidado malloc), por lo que no es adecuado para el uso de la pila en general.

En Standard C y C ++, la matriz de tamaño cero no está permitida.

Si está utilizando GCC, compílelo con la -pedanticopción. Dará advertencia , diciendo:

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

En caso de C ++, da una advertencia similar.

Es totalmente ilegal, y siempre lo ha sido, pero muchos compiladores olvidan señalar el error. No estoy seguro de por qué quieres hacer esto. El único uso que conozco es desencadenar un error de tiempo de compilación desde un booleano:

char someCondition[ condition ];

Si conditiones falso, aparece un error de tiempo de compilación. Sin embargo, debido a que los compiladores sí permiten esto, he empezado a usar:

char someCondition[ 2 * condition - 1 ];

Esto da un tamaño de 1 o -1, y nunca he encontrado un compilador que acepte un tamaño de -1.

Agregaré que hay una página completa de la documentación en línea de gcc sobre este argumento.

Algunas citas:

Las matrices de longitud cero están permitidas en GNU C.

En ISO C90, tendría que dar a los contenidos una longitud de 1

y

Las versiones de GCC anteriores a la 3.0 permitían que las matrices de longitud cero se inicializaran estáticamente, como si fueran matrices flexibles. Además de aquellos casos que fueron útiles, también permitió inicializaciones en situaciones que corromperían datos posteriores

para que puedas

int arr[0] = { 1 };

y bum :-)

Otro uso de matrices de longitud cero es para hacer un objeto de longitud variable (anterior a C99). Las matrices de longitud cero son diferentes de las matrices flexibles que tienen [] sin 0.

Citado de gcc doc :

Las matrices de longitud cero están permitidas en GNU C. Son muy útiles como el último elemento de una estructura que es realmente un encabezado para un objeto de longitud variable:

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

En ISO C99, usaría un miembro de matriz flexible, que es ligeramente diferente en sintaxis y semántica:

• Los miembros de la matriz flexible se escriben como contenido [] sin el 0.
• Los miembros de la matriz flexible tienen un tipo incompleto, por lo que no se puede aplicar el operador sizeof.

Un ejemplo del mundo real es matrices de longitud cero de struct kdbus_itemen kdbus.h (un módulo del kernel de Linux).

Las declaraciones de matriz de tamaño cero dentro de las estructuras serían útiles si se permitieran, y si la semántica fuera tal que (1) forzarían la alineación pero de lo contrario no asignarían ningún espacio, y (2) indexar la matriz se consideraría un comportamiento definido en el caso en el que el puntero resultante estaría dentro del mismo bloque de memoria que la estructura. Tal comportamiento nunca fue permitido por ningún estándar C, pero algunos compiladores más antiguos lo permitieron antes de que se convirtiera en estándar para que los compiladores permitieran declaraciones de matriz incompletas con corchetes vacíos.

El truco de la estructura, como se implementa comúnmente usando una matriz de tamaño 1, es dudoso y no creo que haya ningún requisito de que los compiladores se abstengan de romperlo. Por ejemplo, yo esperaría que si un compilador ve int a[1], estaría dentro de sus derechos respecto a a[i]como a[0]. Si alguien intenta solucionar los problemas de alineación del pirateo de estructuras a través de algo como

typedef struct {
  uint32_t tamaño;
  uint8_t datos [4]; // Use cuatro, para evitar que el relleno arroje el tamaño de la estructura
}

un compilador puede ser inteligente y asumir que el tamaño de la matriz es realmente cuatro:

; Como esta escrito
  foo = myStruct-> datos [i];
; Según lo interpretado (suponiendo hardware little-endian)
  foo = ((* (uint32_t *) myStruct-> data) >> (i << 3)) & 0xFF;

Tal optimización puede ser razonable, especialmente si myStruct->datase puede cargar en un registro en la misma operación que myStruct->size. No sé nada en el estándar que prohibiría tal optimización, aunque, por supuesto, rompería cualquier código que pudiera esperar acceder a cosas más allá del cuarto elemento.