¿Por qué C tendría “matrices falsas”? [closed]

Estoy leyendo El manual de los enemigos de Unix y en el capítulo 9 hay algo que realmente no entiendo:

C realmente tampoco tiene arreglos. Tiene algo que parece una matriz pero en realidad es un puntero a una ubicación de memoria.

Realmente no puedo imaginar ninguna forma de almacenar una matriz en la memoria que no sea usar punteros para indexar ubicaciones de memoria. ¿Cómo C implementa arreglos “falsos” de todos modos? ¿Hay alguna veracidad en esta afirmación?

Creo que el punto del autor es que las matrices C son realmente solo una fina capa de aritmética de punteros. El operador subíndice se define simplemente como a[b] == *(a + b)para que puedas decir fácilmente 5[a] en vez de a[5] y hacer otras cosas horribles como acceder a la matriz más allá del último índice.

En comparación con eso, una “matriz verdadera” sería aquella que conoce su propio tamaño, no le permite hacer aritmética de punteros, acceder más allá del último índice sin un error o acceder a su contenido usando un tipo de elemento diferente. En otras palabras, una “matriz verdadera” es una abstracción estricta que no lo vincula a una sola representación; en su lugar, podría ser una lista vinculada, por ejemplo.

PD. Para ahorrarme algunos problemas: realmente no tengo una opinión sobre esto, solo estoy explicando la cita del libro.

Hay una diferencia entre las matrices C y los punteros, y se puede ver en la salida de sizeof() expresiones Por ejemplo:

void sample1(const char * ptr)
{
   /* s1 depends on pointer size of architecture */
   size_t s1 = sizeof(ptr); 
}
size_t sample2(const char arr[])
{
   /* s2 also depends on pointer size of architecture, because arr decays to pointer */
   size_t s2 = sizeof(arr); 
   return s2;
}
void sample3(void)
{
   const char arr[3];
   /* s3 = 3 * sizeof(char) = 3 */
   size_t s2 = sizeof(arr); 
}
void sample4(void)
{
   const char arr[3];
   /* s4 = output of sample2(arr) which... depends on pointer size of architecture, because arr decays to pointer */
   size_t s4 = sample2(arr); 
}

los sample2 y sample4 en particular, es probablemente la razón por la que las personas tienden a combinar matrices C con punteros C, porque en otros lenguajes simplemente puede pasar matrices como argumento a una función y hacer que funcione ‘igual que’ como lo hizo en la función de llamada. Del mismo modo, debido a cómo funciona C, puede pasar punteros en lugar de matrices y esto es ‘válido’, mientras que en otros lenguajes con una distinción más clara entre matrices y punteros no lo sería.

También podrías ver la sizeof() salida como consecuencia de la semántica de paso por valor de C (ya que las matrices de C se descomponen en punteros).

Además, algunos compiladores también admiten esta sintaxis de C:

void foo(const char arr[static 2])
{
   /* arr must be **at least** 2 elements in size, cannot pass NULL */
}

La declaración que citó es objetivamente incorrecta. Las matrices en C no son punteros.

La idea de implementar matrices como punteros se usó en los lenguajes B y BCPL (ancestros de C), pero no ha sobrevivido a la transición a C. En las primeras edades de C, la “compatibilidad con versiones anteriores” con B y BCPL se consideró algo importante, lo que es por eso que C se ordena de cerca emular el comportamiento de las matrices B y BCPL (es decir, las matrices C “decaen” fácilmente en punteros). Sin embargo, las matrices C no son “punteros a una ubicación de memoria”.

La cita del libro es completamente falsa. Este concepto erróneo está bastante extendido entre los novatos de C. Pero cómo se las arregló para entrar en un libro está más allá de mí.

El autor probablemente quiere decir que las matrices están restringidas de manera que las hacen sentir como ciudadanos de segunda clase desde el punto de vista del programador. Por ejemplo, dos funciones, una está bien, otra no:

int finefunction() {
    int ret = 5;
    return ret;
}

int[] wtffunction() {
    int ret[1] = { 5 };
    return ret;
}

Puede solucionar esto un poco envolviendo arreglos en estructuras, pero solo enfatiza que los arreglos son diferentes, no son como otros tipos.

struct int1 {
    int a[1];
}

int[] finefunction2() {
    struct int1 ret = { { 5 } };
    return ret;
}

Otro efecto de esto es que no puede obtener el tamaño de la matriz en tiempo de ejecución:

int my_sizeof(int a[]) {
    int size = sizeof(a);
    return size;
}

int main() {
    int arr[5];
    // prints 20 4, not 20 20 as it would if arrays were 1st class things
    printf("%d %d\n", sizeof(arr), my_sizeof(arr)); 
}

Otra forma de decir lo que dicen los autores es que, en la terminología de C (y C++), “matriz” significa algo más que en la mayoría de los demás lenguajes.

Entonces, su pregunta de título, ¿cómo se almacenaría una “matriz verdadera” en la memoria? Bueno, no hay un solo tipo de “matriz verdadera”. Si desea matrices verdaderas en C, básicamente tiene dos opciones:

1. Use calloc para asignar el búfer y almacene el puntero y el recuento de elementos aquí

   struct intarrayref {
     size_t count;
     int *data;
   }
   

   Esta estructura es básicamente una referencia a la matriz, y puede pasarla muy bien a funciones, etc. Querrá escribir funciones para operar en ella, como crear una copia de los datos reales.

2. Usar miembro de matriz flexibley asigne toda la estructura con una sola llamada

   struct intarrayobject {
       size_t count;
       int data[];
   }
   

En este caso, asigna tanto los metadatos (count), y el espacio para los datos de la matriz de una sola vez, pero el precio es que ya no puede pasar esta estructura como valor, porque eso dejaría atrás los datos adicionales. Tiene que pasar el puntero a esta estructura a las funciones, etc. Por lo tanto, es una cuestión de opinión si uno consideraría esto como una “matriz verdadera” o simplemente una matriz C normal ligeramente mejorada.

Como todo el libro, es un caso de troleo, específicamente, el tipo de troleo que consiste en afirmar algo casi cierto pero incorrecto para solicitar respuestas airadas sobre por qué está mal. C ciertamente tiene arreglos/tipos de arreglos reales, como lo demuestra la forma en que funcionan los tipos de puntero a arreglo (y los arreglos multidimensionales).