¿Por qué las matrices C no pueden tener longitud 0?

El estándar C11 dice que las matrices, tanto de tamaño variable como de longitud variable "tendrán un valor mayor que cero". ¿Cuál es la justificación para no permitir una longitud de 0?

Especialmente para matrices de longitud variable, tiene mucho sentido tener un tamaño de cero de vez en cuando. También es útil para matrices estáticas cuando su tamaño es de una macro o una opción de configuración de compilación.

Curiosamente, GCC (y clang) proporcionan extensiones que permiten matrices de longitud cero. Java también permite matrices de longitud cero.

El problema que apostaría es que las matrices en C son solo punteros al comienzo de un fragmento de memoria asignado. Tener un tamaño 0 significaría que tienes un puntero para ... ¿nada? No se puede tener nada, por lo que habría tenido que haber algo arbitrario elegido. No puede usar null, porque entonces sus matrices de longitud 0 se verían como punteros nulos. Y en ese punto, cada implementación diferente va a elegir diferentes comportamientos arbitrarios, lo que conducirá al caos.

Veamos cómo se despliega una matriz en la memoria:

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

Tenga en cuenta que no hay un objeto separado llamado arrque almacene la dirección del primer elemento; cuando aparece una matriz en una expresión, C calcula la dirección del primer elemento según sea necesario.

Entonces, pensemos en esto: una matriz de 0 elementos no tendría almacenamiento aparte, lo que significa que no hay nada para calcular la dirección de la matriz (dicho de otra manera, no hay mapeo de objetos para el identificador). Es como decir: "Quiero crear una intvariable que no ocupe memoria". Es una operación sin sentido.

Editar

Las matrices Java son animales completamente diferentes de las matrices C y C ++; no son un tipo primitivo, sino un tipo de referencia derivado de Object.

Editar ²

Un punto que aparece en los comentarios a continuación: la restricción "mayor que 0" solo se aplica a las matrices donde el tamaño se especifica a través de una expresión constante ; Se permite que un VLA tenga una longitud 0 La declaración de un VLA con una expresión no constante con valor 0 no es una violación de restricción, pero invoca un comportamiento indefinido.

Está claro que los VLA son animales diferentes de las matrices regulares , y su implementación puede permitir un tamaño 0 . No se pueden declarar staticni al alcance del archivo, porque el tamaño de dichos objetos debe conocerse antes de que se inicie el programa.

Tampoco vale nada que a partir de C11, las implementaciones no sean necesarias para admitir VLA.

Por lo general, querrá que su matriz de tamaño cero (de hecho variable) sepa su tamaño en tiempo de ejecución. Luego empaquete eso en structy use miembros de matriz flexibles , como por ejemplo:

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

Obviamente, el miembro de la matriz flexible tiene que ser el último structy debe tener algo antes. A menudo eso sería algo relacionado con la longitud real ocupada en tiempo de ejecución de ese miembro de matriz flexible.

Por supuesto que asignarías:

 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, esto ya era posible en C99, y es muy útil.

Por cierto, los miembros de matriz flexible no existen en C ++ (porque sería difícil definir cuándo y cómo deberían construirse y destruirse). Ver sin embargo el futuro std :: dynarray

Si la expresión type name[count]está escrita en alguna función, entonces le indica al compilador de C que asigne en los sizeof(type)*countbytes del marco de la pila y calcule la dirección del primer elemento de la matriz.

Si la expresión type name[count]se escribe fuera de todas las definiciones de funciones y estructuras, entonces le indica al compilador de C que asigne en los sizeof(type)*countbytes del segmento de datos y calcule la dirección del primer elemento en la matriz.

nameen realidad es un objeto constante que almacena la dirección del primer elemento en la matriz y cada objeto que almacena una dirección de alguna memoria se llama puntero, por lo que esta es la razón por la que se trata namecomo un puntero en lugar de una matriz. Tenga en cuenta que solo se puede acceder a las matrices en C a través de punteros.

Si countes una expresión constante que se evalúa a cero, entonces le dice al compilador de C que asigne cero bytes en el marco de la pila o en el segmento de datos y devuelva la dirección del primer elemento de la matriz, pero el problema al hacerlo es que el primer elemento de la matriz de longitud cero no existe y no puede calcular la dirección de algo que no existe.

Esto es racional ese elemento no. count+1no existe en la countmatriz de longitud, por lo que esta es la razón por la que el compilador de C prohíbe definir la matriz de longitud cero como variable dentro y fuera de una función, porque ¿cuál es el contenido de nameentonces? Que direccionname almacena exactamente?

Si pes un puntero, entonces la expresión p[n]es equivalente a*(p + n)

Donde el asterisco * en la expresión derecha es la operación de desreferencia del puntero, lo que significa acceder a la memoria apuntada p + no acceder a la memoria cuya dirección está almacenada p + n, donde p + nes la expresión del puntero, toma la dirección py agrega a esta dirección el número nmultiplica el tamaño del tipo de puntero p.

¿Es posible agregar una dirección y un número?

Sí, es posible, porque la dirección es un entero sin signo comúnmente representado en notación hexadecimal.

Si desea un puntero a una dirección de memoria, declare uno. Una matriz en realidad apunta a un trozo de memoria que ha reservado. Las matrices decaen a punteros cuando se pasan a funciones, pero si la memoria a la que apuntan está en el montón, no hay problema. No hay razón para declarar una matriz de tamaño cero.

Desde los días del C89 original, cuando un Estándar C especificaba que algo tenía un Comportamiento Indefinido, lo que eso significaba era "Hacer lo que sea que haga que una implementación en una plataforma objetivo particular sea la más adecuada para su propósito". Los autores de la Norma no querían tratar de adivinar qué comportamientos podrían ser más adecuados para un propósito particular. Las implementaciones existentes de C89 con extensiones VLA podrían haber tenido comportamientos diferentes, pero lógicos, cuando se les dio un tamaño de cero (por ejemplo, algunos podrían haber tratado la matriz como una expresión de dirección que genera NULL, mientras que otros la trataron como una expresión de dirección que podría ser igual a la dirección de otra variable arbitraria, pero con seguridad podría agregar cero sin atrapar). Si algún código pudiera haberse basado en un comportamiento tan diferente, los autores de la Norma no

En lugar de tratar de adivinar lo que podrían hacer las implementaciones, o sugerir que cualquier comportamiento debería considerarse superior a cualquier otro, los autores de la Norma simplemente permitieron que los implementadores usaran el juicio al manejar ese caso lo mejor que creían conveniente. Las implementaciones que usan malloc () detrás de escena pueden tratar la dirección de la matriz como NULL (si malloc de tamaño cero produce un valor nulo), aquellas que usan cálculos de direcciones de pila podrían generar un puntero que coincida con la dirección de alguna otra variable, y algunas otras implementaciones podrían funcionar otras cosas. No creo que esperaran que los escritores de compiladores hicieran todo lo posible para que el caso de la esquina de tamaño cero se comportara de manera deliberadamente inútil.