Por lo que recuerdo, las matrices siempre se pasan como punteros. Por ejemplo, la declaración:
void foo(int array[2][5]);significa para el compilador exactamente lo mismo que:
void foo(int (*array)[5]);Se puede decir que estas dos formas son equivalentes. Ahora, me pregunto, ¿por qué se permite entonces declararlo como:
void foo(int (*array)[]);mientras no como:
void foo(int array[][]);Tome un ejemplo:
#include <stdio.h> void foo(int (*p)[3]); void bar(int (*p)[]); int main(void) { int a[2][3] = {{1, 2, 3}, {4, 5, 6}}; foo(a); bar(a); return 0; } // The same as int p[][3] or int p[N][3] where N is a constant expression void foo(int (*p)[3]) { } // Would it the same as int p[][] or int p[N][] (by analogy)? void bar(int (*p)[]) { } Se compila bien y sin advertencias, pero si cambio la declaración de bar a:
void bar(int p[][]);entonces es un error.
¿Por qué C permite una forma tan "oscura" de pasar una matriz?
Las matrices no son punteros, si declara una matriz de punteros con un tamaño no especificado, está bien porque almacenará las direcciones almacenadas en los punteros de forma conjunta y se conoce el tamaño de cada elemento, pero p[][] requeriría que las matrices sean conjuntas no sus direcciones y el tamaño de la matriz es desconocido, así que ese es el problema.
Para que quede claro, si dices int p[][] , no sabes qué tan lejos está p[0] de p[1] mientras que en int (*p)[] sabes que la distancia es del tamaño de un puntero.
Las matrices se convierten en punteros, pero no son punteros.
Las matrices se pueden usar como punteros, pero son más que punteros; apuntan a una serie de cosas que tienen un tamaño. De esa manera, puede decirle al compilador que está interesado en el tercer o quinto elemento de su matriz, y calculará la ubicación de ese elemento multiplicando el tamaño de un elemento por tres o cinco para encontrar un desplazamiento, y sumando eso desplazamiento a la dirección de la matriz.
C en realidad no tiene arreglos multidimensionales. Lo que sí tiene son arreglos de arreglos, que es más o menos lo mismo. Di que tienes esto:
int a[4][5];En la memoria, esto se vería así:
[0] |[1] |[2] |[3] +-------------------|-------------------|-------------------|-------------------+ a | | | | | | | | | | | | | X | | | | | | | | +-------------------|-------------------|-------------------|-------------------+ 0 1 2 3 4 | 0 1 2 3 4 | 0 1 2 3 4 | 0 1 2 3 4 | y luego intenta acceder al elemento en el índice [2][2] , entonces el sistema necesita realizar el siguiente cálculo (conceptualmente):
En este caso, el cálculo es *(a + (2 * 5 * sizeof(int)) + (2 * sizeof(int))) , dando *(a + 12*sizeof(int)) , que de hecho es el correcto desplazamiento desde el puntero inicial.
Todo lo que significa es que el tamaño de la matriz interna debe definirse para que el compilador pueda hacer ese cálculo. Si no define el tamaño de ninguna dimensión (excepto la más a la izquierda) de su matriz multidimensional, no tiene un tamaño definido y el compilador se resistirá.
Está tropezando con el soporte del lenguaje C para matrices de tamaño 'no especificado', que puede declarar, pero generalmente no puede usar directamente a menos que le dé un tamaño más específico en alguna parte.
En su ejemplo, si realmente intenta hacer algo con la matriz en bar , obtendrá un error:
void bar(int (*p)[]) { printf("%d\n", p[1][1]); } % gcc -Wall tc tc: In function 'bar': tc:23:5: error: invalid use of array with unspecified bounds printf("%d\n", p[1][1]); ^ Lo único que puede hacer con p en la barra es convertirlo en algún tipo con un tamaño explícito, o pasarlo a alguna otra función que lleve un puntero a una matriz (de tamaño especificado o no especificado), y si usa el explícito incorrecto size para intentar acceder a la matriz, obtiene un comportamiento indefinido sin advertencia.