O que acontece se eu definir uma matriz de tamanho 0 em C / C ++?

Apenas curioso, o que realmente acontece se eu definir uma matriz de comprimento zero int array[0];no código? O GCC não reclama de forma alguma.

Programa de amostra

#include <stdio.h>

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

Esclarecimento

Na verdade, estou tentando descobrir se matrizes de comprimento zero inicializadas dessa maneira, em vez de serem apontadas como o comprimento variável nos comentários de Darhazer, são otimizadas ou não.

Isso ocorre porque eu tenho que liberar algum código para a natureza, então estou tentando descobrir se devo lidar com casos em que o SIZEé definido como 0, o que acontece em algum código com um estaticamente definidoint array[SIZE];

Fiquei realmente surpreso que o GCC não reclame, o que levou à minha pergunta. Das respostas que recebi, acredito que a falta de um aviso se deve em grande parte ao suporte ao código antigo que não foi atualizado com a nova sintaxe [].

Como eu estava pensando principalmente no erro, estou rotulando a resposta de Lundin como correta (a de Nawaz foi a primeira, mas não tão completa) - os outros estavam apontando seu uso real para estruturas acolchoadas, embora relevantes, não são ' exatamente o que eu estava procurando.

Uma matriz não pode ter tamanho zero.

ISO 9899: 2011 6.7.6.2:

Se a expressão for uma expressão constante, ela deverá ter um valor maior que zero.

O texto acima é verdadeiro tanto para uma matriz simples (parágrafo 1). Para um VLA (array de comprimento variável), o comportamento é indefinido se o valor da expressão for menor ou igual a zero (parágrafo 5). Este é um texto normativo no padrão C. Um compilador não tem permissão para implementá-lo de maneira diferente.

gcc -std=c99 -pedantic emite um aviso para o caso não-VLA.

Conforme o padrão, não é permitido.

No entanto, é prática corrente nos compiladores C tratar essas declarações como uma declaração de membro de matriz flexível ( FAM ) :

C99 6.7.2.1, §16 : Como caso especial, o último elemento de uma estrutura com mais de um membro nomeado pode ter um tipo de matriz incompleto; isso é chamado de membro flexível da matriz.

A sintaxe padrão de uma FAM é:

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

A ideia é que você o aloque assim:

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

Você também pode usá-lo estaticamente (extensão gcc):

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

Isso também é conhecido como estruturas acolchoadas (este termo é anterior à publicação do C99 Standard) ou struct hack (obrigado Joe Wreschnig por apontá-lo).

No entanto, essa sintaxe foi padronizada (e os efeitos garantidos) apenas recentemente em C99. Antes era necessário um tamanho constante.

• 1 era o caminho portátil a seguir, embora fosse bastante estranho.
• 0 foi melhor em indicar intenção, mas não é legal no que diz respeito ao Padrão e foi suportado como uma extensão por alguns compiladores (incluindo o gcc).

A prática de preenchimento da cauda, ​​no entanto, depende do fato de que o armazenamento está disponível (cuidado malloc), portanto, não é adequado para empilhar o uso em geral.

No padrão C e C ++, a matriz de tamanho zero não é permitida.

Se você estiver usando o GCC, compile-o com a -pedanticopção Dará aviso , dizendo:

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

No caso de C ++, ele fornece um aviso semelhante.

É totalmente ilegal, e sempre foi, mas muitos compiladores negligenciam o sinal do erro. Não sei por que você quer fazer isso. O único uso que eu sei é acionar um erro de tempo de compilação de um booleano:

char someCondition[ condition ];

Se conditioné um falso, então eu recebo um erro de tempo de compilação. Como os compiladores permitem isso, no entanto, passei a usar:

char someCondition[ 2 * condition - 1 ];

Isso fornece um tamanho de 1 ou -1, e eu nunca encontrei um compilador que aceitasse um tamanho de -1.

Acrescentarei que há uma página inteira da documentação on-line do gcc sobre esse argumento.

Algumas citações:

Matrizes de comprimento zero são permitidas no GNU C.

Na ISO C90, você teria que fornecer ao conteúdo um comprimento de 1

e

As versões do GCC anteriores ao 3.0 permitiam que matrizes de tamanho zero fossem inicializadas estaticamente, como se fossem matrizes flexíveis. Além dos casos úteis, também permitiu inicializações em situações que corromperiam dados posteriores

então você poderia

int arr[0] = { 1 };

e boom :-)

Outro uso de matrizes de comprimento zero é para criar objetos de comprimento variável (pré-C99). Matrizes de comprimento zero são diferentes das matrizes flexíveis que têm [] sem 0.

Citado no documento gcc :

Matrizes de comprimento zero são permitidas no GNU C. Elas são muito úteis como o último elemento de uma estrutura que é realmente um cabeçalho para um objeto de comprimento variável:

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

Na ISO C99, você usaria um membro flexível da matriz, que é um pouco diferente na sintaxe e na semântica:

• Membros flexíveis da matriz são gravados como conteúdo [] sem o 0.
• Membros de matriz flexíveis têm tipo incompleto e, portanto, o operador sizeof pode não ser aplicado.

Um exemplo do mundo real são matrizes de comprimento zero struct kdbus_itemno kdbus.h (um módulo do kernel do Linux).

Declarações de matriz de tamanho zero dentro de estruturas seriam úteis se fossem permitidas e se a semântica fosse tal que (1) forçasse o alinhamento, mas não alocasse espaço, e (2) indexasse a matriz seria considerado um comportamento definido no caso em que o ponteiro resultante estaria dentro do mesmo bloco de memória que a estrutura. Esse comportamento nunca foi permitido por nenhum padrão C, mas alguns compiladores antigos o permitiram antes que se tornasse padrão para os compiladores permitirem declarações de matriz incompletas com colchetes vazios.

O truque de estrutura, como geralmente implementado usando uma matriz de tamanho 1, é desonesto e não acho que exista nenhum requisito de que os compiladores evitem quebrá-lo. Por exemplo, seria de esperar que se um compilador vê int a[1], seria no seu direito de respeito a[i]como a[0]. Se alguém tentar solucionar os problemas de alinhamento do struct hack através de algo como

typedef struct {
  tamanho uint32_t;
  dados uint8_t [4]; // Use four, para evitar que o preenchimento diminua o tamanho da estrutura
}

um compilador pode ficar esperto e assumir que o tamanho da matriz é realmente quatro:

; Como escrito
  foo = myStruct-> dados [i];
; Como interpretado (assumindo hardware little-endian)
  foo = ((* (uint32_t *) myStruct-> dados) >> (i << 3)) & 0xFF;

Essa otimização pode ser razoável, especialmente se myStruct->datapuder ser carregada em um registro na mesma operação que myStruct->size. Não sei nada no padrão que proíba essa otimização, embora, é claro, quebre qualquer código que possa esperar acessar coisas além do quarto elemento.