Por que as matrizes C não podem ter comprimento 0?

O padrão C11 diz que as matrizes, tamanho e tamanho variável "devem ter um valor maior que zero". Qual é a justificativa para não permitir um comprimento de 0?

Especialmente para matrizes de comprimento variável, faz todo o sentido ter um tamanho zero de vez em quando. Também é útil para matrizes estáticas quando seu tamanho é de uma opção de configuração de macro ou compilação.

Curiosamente, o GCC (e clang) fornece extensões que permitem matrizes de comprimento zero. Java também permite matrizes de comprimento zero.

O problema que eu apostaria é que as matrizes C são apenas indicadores do início de um pedaço de memória alocado. Ter um tamanho 0 significaria que você tem um ponteiro para ... nada? Você não pode ter nada, então teria que haver alguma coisa arbitrária escolhida. Você não pode usar null, porque suas matrizes de comprimento 0 pareceriam ponteiros nulos. E nesse ponto, cada implementação diferente escolherá comportamentos arbitrários diferentes, levando ao caos.

Vejamos como uma matriz é tipicamente organizada na memória:

         +----+
arr[0] : |    |
         +----+
arr[1] : |    |
         +----+
arr[2] : |    |
         +----+
          ...
         +----+
arr[n] : |    |
         +----+

Observe que não há um objeto separado nomeado arrque armazena o endereço do primeiro elemento; quando uma matriz aparece em uma expressão, C calcula o endereço do primeiro elemento, conforme necessário.

Então, vamos pensar sobre isso: uma matriz com 0 elementos não teria armazenamento reservado para ela, o que significa que não há nada para calcular o endereço da matriz (em outras palavras , não há mapeamento de objetos para o identificador). É como dizer: "Quero criar uma intvariável que não ocupa memória". É uma operação sem sentido.

Editar

Matrizes Java são animais completamente diferentes das matrizes C e C ++; eles não são um tipo primitivo, mas um tipo de referência derivado Object.

Editar ²

Um ponto levantado nos comentários abaixo - a restrição "maior que 0" se aplica apenas a matrizes em que o tamanho é especificado por meio de uma expressão constante ; é permitido que um VLA tenha um comprimento 0 Declarar um VLA com uma expressão não constante com valor 0 não é uma violação de restrição, mas invoca um comportamento indefinido.

É claro que os VLAs são animais diferentes das matrizes regulares e sua implementação pode permitir um tamanho 0 . Eles não podem ser declarados staticou no escopo do arquivo, porque o tamanho desses objetos deve ser conhecido antes do início do programa.

Também não vale nada que, a partir do C11, as implementações não sejam necessárias para dar suporte aos VLAs.

Você normalmente deseja que sua matriz de tamanho zero (de fato variável) saiba seu tamanho em tempo de execução. Em seguida, coloque-o em um structe use membros de matriz flexíveis , como por exemplo:

struct my_st {
   unsigned len;
   double flexarray[]; // of size len
};

Obviamente, o membro da matriz flexível deve ser o último structe você precisa ter algo antes. Frequentemente, isso seria algo relacionado ao comprimento real em tempo de execução desse membro flexível da matriz.

Claro que você alocaria:

 unsigned len = some_length_computation();
 struct my_st*p = malloc(sizeof(struct my_st)+len*sizeof(double));
 if (!p) { perror("malloc my_st"); exit(EXIT_FAILURE); };
 p->len = len;
 for (unsigned ix=0; ix<len; ix++)
    p->flexarray[ix] = log(3.0+(double)ix);

AFAIK, isso já era possível no C99 e é muito útil.

BTW, os membros flexíveis da matriz não existem em C ++ (porque seria difícil definir quando e como eles devem ser construídos e destruídos). No entanto, veja o futuro std :: dynarray

Se a expressão type name[count]estiver escrita em alguma função, você solicita que o compilador C aloque nos sizeof(type)*countbytes do quadro da pilha e calcule o endereço do primeiro elemento na matriz.

Se a expressão type name[count]for gravada fora de todas as funções e definições de estruturas, você instrui o compilador C a alocar nos sizeof(type)*countbytes do segmento de dados e computa o endereço do primeiro elemento na matriz.

namena verdade, é um objeto constante que armazena o endereço do primeiro elemento na matriz e todo objeto que armazena um endereço de alguma memória é chamado ponteiro; portanto, esse é o motivo pelo qual você trata namecomo ponteiro, e não como matriz. Observe que as matrizes em C podem ser acessadas apenas através de ponteiros.

Se counté uma expressão constante avaliada como zero, você diz ao compilador C para alocar zero bytes no quadro da pilha ou no segmento de dados e retorna o endereço do primeiro elemento na matriz, mas o problema é que o primeiro elemento da matriz de comprimento zero não existe e você não pode calcular o endereço de algo que não existe.

É racional esse elemento não. count+1não existe na countmatriz -length, portanto, esse é o motivo pelo qual o compilador C proíbe definir a matriz de comprimento zero como variável dentro e fora de uma função, porque qual é o conteúdo namedela? Que endereço namearmazena exatamente?

Se pé um ponteiro, a expressão p[n]é equivalente a*(p + n)

Onde o asterisco * na expressão correta é uma operação de desreferência do ponteiro, o que significa acessar a memória apontada p + nou acessar a memória cujo endereço está armazenado p + n, onde p + nestá a expressão do ponteiro, ele pega o endereço de pe adiciona a esse endereço o número nmultiplique o tamanho do tipo do ponteiro p.

É possível adicionar um endereço e um número?

Sim, é possível, porque o endereço é um número inteiro sem sinal geralmente representado na notação hexadecimal.

Se você deseja um ponteiro para um endereço de memória, declare um. Uma matriz, na verdade, aponta para um pedaço de memória que você reservou. As matrizes se deterioram para os ponteiros quando passadas para as funções, mas se a memória apontada estiver na pilha, não há problema. Não há motivo para declarar uma matriz de tamanho zero.

Desde os dias do C89 original, quando um Padrão C especificava que algo tinha Comportamento Indefinido, o que isso significava era "Fazer o que tornaria uma implementação em uma plataforma de destino específica mais adequada para a finalidade pretendida". Os autores da Norma não quiseram adivinhar quais comportamentos poderiam ser mais adequados para qualquer finalidade específica. As implementações C89 existentes com extensões VLA podem ter comportamentos diferentes, mas lógicos, quando recebem tamanho zero (por exemplo, alguns podem ter tratado a matriz como uma expressão de endereço que produz NULL, enquanto outros a tratam como uma expressão de endereço que pode ser igual ao endereço de outra variável arbitrária, mas poderia com segurança adicionar zero a ela sem capturar). Se algum código pudesse ter se baseado em comportamentos tão diferentes, os autores da Norma não

Em vez de tentar adivinhar o que as implementações podem fazer, ou sugerir que qualquer comportamento deve ser considerado superior a qualquer outro, os autores da Norma simplesmente permitiram que os implementadores usassem julgamento ao lidar com esse caso da melhor maneira que quisessem. Implementações que usam malloc () nos bastidores podem tratar o endereço da matriz como NULL (se malloc de tamanho zero gerar nulo), aquelas que usam cálculos de endereço de pilha podem gerar um ponteiro que corresponde ao endereço de alguma outra variável, e algumas outras implementações podem fazer outras coisas. Eu não acho que eles esperavam que os escritores de compiladores se esforçassem para fazer com que a caixa de canto de tamanho zero se comporte de maneira deliberadamente inútil.