retornar - Desintegración de matrices multidimensionales como parámetros de función.
matriz como parametro de funcion c (4)
Cuando una matriz decae, se convierte en un puntero al primer elemento. En el caso de int a[3][4] , a es una matriz de int[4] , por lo que un puntero a un elemento de int [3][4] tiene el tipo int (*)[4] .
Así que esto:
void foo(int a[3][4])
Es lo mismo que:
void foo(int (*a)[4])
Sé que por ejemplo esto:
void foo(int a[])// or a[x]
Será considerado por el compilador así:
void foo(int *a)
Pero no lo sé, y no encontré en ningún lado cómo se ven los arreglos multidimensionales por el compilador
Por ejemplo:
void foo(int a[3][4])
¿Será algo como esto?
void foo(int (*a)[4])
¿O algo como esto?
void foo(int **a)
El compilador no puede indexar una matriz multidimensional pasada para funcionar correctamente sin conocer todas las dimensiones excepto la más externa.
Así que para una matriz 1D no se necesita longitud:
void foo(int a[]);
y
void foo(int a[3]);
son iguales aunque engañosos, porque C no presta atención a la longitud de una matriz: eso es para que el programador haga lo correcto.
Para una matriz 2D, la dimensión interna tiene que ser correcta, o el compilador no sabrá cómo indexarla. Asi que
void foo(int a[][3]);
es bueno pero
void foo(int a[][]);
no puede ser codificado, y
void foo(int a[42][3]);
es bueno pero innecesario y no es restrictivo, ya que todas las necesidades del compilador son la información sobre cómo indexar, y no cuánto .
Los arreglos multidimensionales a menudo son una fuente de problemas, especialmente si desea permitir un tamaño dinámico.
En el caso general, sugeriría utilizar
void foo(int* a, int size1, int size2);
o
void foo(int* a, int numSizes, int* sizes);
Al pasar explícitamente el tamaño, se limitan las segregaciones muy comunes que se obtendrían debido a la caída del puntero y la falta de comprobación. El uso de tipos de matriz es muy frágil y no se recomienda en la mayoría de los casos.
También es posible que desee especificar el método de indexación, generalmente es a[size1*i+j] pero es posible que desee algo más.
void foo(int a[3][4])
a es una matriz de longitud 3, que consiste en matrices int de 4 elementos.
Así es como se ve:
+---+---+---+---+
| 0 | 1 | 2 | 3 |
+---+---+---+---+
| 0 | 1 | 2 | 3 |
+---+---+---+---+
| 0 | 1 | 2 | 3 |
+---+---+---+---+
Puede agregar filas, pero no puede agregar columnas, porque el acceso al elemento de k[3][4] se realiza como a[3][2] = a[3*4 + 2] . Esta es la forma de encontrar un cuadro del diagrama anterior usando el conocimiento de la fila y la columna. La ecuación a[b][c] = a[b * row_number + c] no se mantiene cuando la matriz no es cuadrada. Decir,
+---+---+---+---+---+
| 0 | 1 | 2 | 3 | 4 |
+---+---+---+---+---+
| 0 | 1 | 2 | 3 |
+---+---+---+---+
¿Tú lo entiendes?
Mira la primera tabla de arriba. Se podría enumerar de una manera diferente. Qué tal si:
+---+---+----+----+
| 0 | 1 | 2 | 3 |
+---+---+----+----+
| 4 | 5 | 6 | 7 |
+---+---+----+----+
| 8 | 9 | 10 | 11 |
+---+---+----+----+
en realidad (porque es una matriz, no una tabla)
+---+---+---+---+---+---+---+---+---+---+----+----+
| 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 |
+---+---+---+---+---+---+---+---+---+---+----+----+
Vea, en C, una matriz 2D es una matriz unidimensional, solo con diferentes índices. Así podría escribirse como:
void foo(int a[])
o
void foo(int *a)
Qué pasa
void foo(int **a)
Es una serie de referencias a matrices int. Esto no es una matriz 2D. Por el contrario, puede ser útil en raras ocasiones. Por ejemplo, cuando desea tener una matriz 2D, las matrices internas (filas) tienen diferentes longitudes. Además, es cómo Java maneja matrices 2D.