C Language
Pasar arrays 2D a funciones
Buscar..
Pasar una matriz 2D a una función
Pasar una matriz 2d a una función parece simple y obvio y con gusto escribimos:
#include <stdio.h>
#include <stdlib.h>
#define ROWS 3
#define COLS 2
void fun1(int **, int, int);
int main()
{
int array_2D[ROWS][COLS] = { {1, 2}, {3, 4}, {5, 6} };
int n = ROWS;
int m = COLS;
fun1(array_2D, n, m);
return EXIT_SUCCESS;
}
void fun1(int **a, int n, int m)
{
int i, j;
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
printf("array[%d][%d]=%d\n", i, j, a[i][j]);
}
}
}
Pero el compilador, aquí GCC en la versión 4.9.4, no lo aprecia bien.
$ gcc-4.9 -O3 -g3 -W -Wall -Wextra -std=c11 passarr.c -o passarr
passarr.c: In function ‘main’:
passarr.c:16:8: warning: passing argument 1 of ‘fun1’ from incompatible pointer type
fun1(array_2D, n, m);
^
passarr.c:8:6: note: expected ‘int **’ but argument is of type ‘int (*)[2]’
void fun1(int **, int, int);
Las razones para esto son dobles: el problema principal es que las matrices no son punteros y el segundo inconveniente es la llamada decadencia del puntero . Pasar una matriz a una función hará que decaiga la matriz a un puntero al primer elemento de la matriz; en el caso de una matriz 2d, decae a un puntero a la primera fila porque en C las matrices se ordenan primero en la fila.
#include <stdio.h>
#include <stdlib.h>
#define ROWS 3
#define COLS 2
void fun1(int (*)[COLS], int, int);
int main()
{
int array_2D[ROWS][COLS] = { {1, 2}, {3, 4}, {5, 6} };
int n = ROWS;
int m = COLS;
fun1(array_2D, n, m);
return EXIT_SUCCESS;
}
void fun1(int (*a)[COLS], int n, int m)
{
int i, j;
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
printf("array[%d][%d]=%d\n", i, j, a[i][j]);
}
}
}
Es necesario pasar el número de filas, que no se pueden calcular.
#include <stdio.h>
#include <stdlib.h>
#define ROWS 3
#define COLS 2
void fun1(int (*)[COLS], int);
int main()
{
int array_2D[ROWS][COLS] = { {1, 2}, {3, 4}, {5, 6} };
int rows = ROWS;
/* works here because array_2d is still in scope and still an array */
printf("MAIN: %zu\n",sizeof(array_2D)/sizeof(array_2D[0]));
fun1(array_2D, rows);
return EXIT_SUCCESS;
}
void fun1(int (*a)[COLS], int rows)
{
int i, j;
int n, m;
n = rows;
/* Works, because that information is passed (as "COLS").
It is also redundant because that value is known at compile time (in "COLS"). */
m = (int) (sizeof(a[0])/sizeof(a[0][0]));
/* Does not work here because the "decay" in "pointer decay" is meant
literally--information is lost. */
printf("FUN1: %zu\n",sizeof(a)/sizeof(a[0]));
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
printf("array[%d][%d]=%d\n", i, j, a[i][j]);
}
}
}
El número de columnas está predefinido y, por lo tanto, se fija en tiempo de compilación, pero el predecesor del estándar C actual (que era ISO / IEC 9899: 1999, actual es ISO / IEC 9899: 2011) implementó VLAs (TODO: enlace) y aunque el estándar actual lo hizo opcional, casi todos los compiladores C modernos lo admiten (TODO: verifica si MS Visual Studio lo admite ahora).
#include <stdio.h>
#include <stdlib.h>
/* ALL CHECKS OMMITTED!*/
void fun1(int (*)[], int rows, int cols);
int main(int argc, char **argv)
{
int rows, cols, i, j;
if(argc != 3){
fprintf(stderr,"Usage: %s rows cols\n",argv[0]);
exit(EXIT_FAILURE);
}
rows = atoi(argv[1]);
cols = atoi(argv[2]);
int array_2D[rows][cols];
for (i = 0; i < rows; i++) {
for (j = 0; j < cols; j++) {
array_2D[i][j] = (i + 1) * (j + 1);
printf("array[%d][%d]=%d\n", i, j, array_2D[i][j]);
}
}
fun1(array_2D, rows, cols);
exit(EXIT_SUCCESS);
}
void fun1(int (*a)[], int rows, int cols)
{
int i, j;
int n, m;
n = rows;
/* Does not work anymore, no sizes are specified anymore
m = (int) (sizeof(a[0])/sizeof(a[0][0])); */
m = cols;
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
printf("array[%d][%d]=%d\n", i, j, a[i][j]);
}
}
}
Esto no funciona, el compilador se queja:
$ gcc-4.9 -O3 -g3 -W -Wall -Wextra -std=c99 passarr.c -o passarr
passarr.c: In function ‘fun1’:
passarr.c:168:7: error: invalid use of array with unspecified bounds
printf("array[%d][%d]=%d\n", i, j, a[i][j]);
Se vuelve un poco más claro si intencionalmente cometemos un error en la llamada de la función al cambiar la declaración a void fun1(int **a, int rows, int cols) . Eso hace que el compilador se queje de una manera diferente, pero igualmente nebulosa
$ gcc-4.9 -O3 -g3 -W -Wall -Wextra -std=c99 passarr.c -o passarr
passarr.c: In function ‘main’:
passarr.c:208:8: warning: passing argument 1 of ‘fun1’ from incompatible pointer type
fun1(array_2D, rows, cols);
^
passarr.c:185:6: note: expected ‘int **’ but argument is of type ‘int (*)[(sizetype)(cols)]’
void fun1(int **, int rows, int cols);
Podemos reaccionar de varias maneras, una de ellas es ignorar todo y hacer un malabarismo de punteros ilegibles:
#include <stdio.h>
#include <stdlib.h>
/* ALL CHECKS OMMITTED!*/
void fun1(int (*)[], int rows, int cols);
int main(int argc, char **argv)
{
int rows, cols, i, j;
if(argc != 3){
fprintf(stderr,"Usage: %s rows cols\n",argv[0]);
exit(EXIT_FAILURE);
}
rows = atoi(argv[1]);
cols = atoi(argv[2]);
int array_2D[rows][cols];
printf("Make array with %d rows and %d columns\n", rows, cols);
for (i = 0; i < rows; i++) {
for (j = 0; j < cols; j++) {
array_2D[i][j] = i * cols + j;
printf("array[%d][%d]=%d\n", i, j, array_2D[i][j]);
}
}
fun1(array_2D, rows, cols);
exit(EXIT_SUCCESS);
}
void fun1(int (*a)[], int rows, int cols)
{
int i, j;
int n, m;
n = rows;
m = cols;
printf("\nPrint array with %d rows and %d columns\n", rows, cols);
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
printf("array[%d][%d]=%d\n", i, j, *( (*a) + (i * cols + j)));
}
}
}
O lo hacemos bien y pasamos la información necesaria a fun1 . Para hacerlo necesitamos reorganizar los argumentos para fun1 : el tamaño de la columna debe venir antes de la declaración de la matriz. Para mantenerlo más legible, la variable que mantiene el número de filas también ha cambiado su lugar, y ahora es la primera.
#include <stdio.h>
#include <stdlib.h>
/* ALL CHECKS OMMITTED!*/
void fun1(int rows, int cols, int (*)[]);
int main(int argc, char **argv)
{
int rows, cols, i, j;
if(argc != 3){
fprintf(stderr,"Usage: %s rows cols\n",argv[0]);
exit(EXIT_FAILURE);
}
rows = atoi(argv[1]);
cols = atoi(argv[2]);
int array_2D[rows][cols];
printf("Make array with %d rows and %d columns\n", rows, cols);
for (i = 0; i < rows; i++) {
for (j = 0; j < cols; j++) {
array_2D[i][j] = i * cols + j;
printf("array[%d][%d]=%d\n", i, j, array_2D[i][j]);
}
}
fun1(rows, cols, array_2D);
exit(EXIT_SUCCESS);
}
void fun1(int rows, int cols, int (*a)[cols])
{
int i, j;
int n, m;
n = rows;
m = cols;
printf("\nPrint array with %d rows and %d columns\n", rows, cols);
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
printf("array[%d][%d]=%d\n", i, j, a[i][j]);
}
}
}
Esto parece incómodo para algunas personas, que opinan que el orden de las variables no debería importar. Eso no es un gran problema, simplemente declare un puntero y deje que apunte a la matriz.
#include <stdio.h>
#include <stdlib.h>
/* ALL CHECKS OMMITTED!*/
void fun1(int rows, int cols, int **);
int main(int argc, char **argv)
{
int rows, cols, i, j;
if(argc != 3){
fprintf(stderr,"Usage: %s rows cols\n",argv[0]);
exit(EXIT_FAILURE);
}
rows = atoi(argv[1]);
cols = atoi(argv[2]);
int array_2D[rows][cols];
printf("Make array with %d rows and %d columns\n", rows, cols);
for (i = 0; i < rows; i++) {
for (j = 0; j < cols; j++) {
array_2D[i][j] = i * cols + j;
printf("array[%d][%d]=%d\n", i, j, array_2D[i][j]);
}
}
// a "rows" number of pointers to "int". Again a VLA
int *a[rows];
// initialize them to point to the individual rows
for (i = 0; i < rows; i++) {
a[i] = array_2D[i];
}
fun1(rows, cols, a);
exit(EXIT_SUCCESS);
}
void fun1(int rows, int cols, int **a)
{
int i, j;
int n, m;
n = rows;
m = cols;
printf("\nPrint array with %d rows and %d columns\n", rows, cols);
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
printf("array[%d][%d]=%d\n", i, j, a[i][j]);
}
}
}
Usando matrices planas como matrices 2D
A menudo, la solución más sencilla es simplemente pasar matrices 2D y superiores como memoria plana.
/* create 2D array with dimensions determined at runtime */
double *matrix = malloc(width * height * sizeof(double));
/* initialise it (for the sake of illustration we want 1.0 on the diagonal) */
int x, y;
for (y = 0; y < height; y++)
{
for (x = 0; x < width; x++)
{
if (x == y)
matrix[y * width + x] = 1.0;
else
matrix[y * width + x] = 0.0;
}
}
/* pass it to a subroutine */
manipulate_matrix(matrix, width, height);
/* do something with the matrix, e.g. scale by 2 */
void manipulate_matrix(double *matrix, int width, int height)
{
int x, y;
for (y = 0; y < height; y++)
{
for (x = 0; x < width; x++)
{
matrix[y * width + x] *= 2.0;
}
}
}
