Implementación de arreglo de 2-D como función

[FERNIIIIN]

Buenas chicos, intento implementar una función que imprima los valores de un arreglo 2-d, pero no se que poner en el parámetro donde va la segunda dimensión, con malloc pido memoria para un int o que me recomiendan.

Aqui tengo el problema:

Código (c) [Seleccionar] Expandir


void muestra(int matriz[][], int renglon, int columna)


El valor de las dimensiones de mi array es variable, bien puede ser 2x 3 o 20x20.
Lo que tengo de código es:

Código (c) [Seleccionar] Expandir


void muestra(int matriz[][], int renglon, int columna);

int main() {
  int M, N, i, j;

scanf("%d %d", &M, &N);

  int b_minas [M][N];

  for (i= 0; i < M; i++) {
    for (j= 0; j < N; j++) {
    scanf("%d", &b_minas[i][j]);
    }
  }
  muestra( b_minas, M, N);


  return 0;
}

void muestra(int matriz[][], int renglon, int columna) {
  printf("\n");
  int i, j;

  for (i= 0; i < renglon; i++) {
    for (j= 0; j < columna; j++) {
    printf("%d ", matriz[i][j]);
    }
    printf("\n");
  }
}


[K-YreX]

Una opción es que uses memoria dinámica y entonces puedes pasar como parámetro un doble puntero. Sin embargo si no has dado memoria dinámica lo que se suele hacer para casos de estos es declarar una matriz más grande de lo necesaria.

Código (c) [Seleccionar] Expandir


const int TAM = 100;

void mostrarMatriz(int[][TAM], int, int);

int main(){
   int matriz[TAM][TAM];
   int fila = 10, col = 10;

   mostrarMatriz(matriz, fila, col);
}

void mostrarMatriz(int matriz[][TAM], int fila, int col){
   for(int i = 0; i < fila; i++){
       for(int j = 0; j < col; j++)
           printf("%d  ", matriz[i][j]);
       printf("\n");
   }
}

Es un desperdicio de memoria pero recuerdo que cuando yo estudiaba los temas de arrays n-dimensionales sin memoria dinámica siempre se hacía así. Creas un tamaño inicial más grande de lo necesario y con otra u otras variables indicas cuál es la parte útil.

Espero que te sirva.

PD: Si prefieres usar memoria dinámica y quieres que te ayude con eso coméntamelo.

[AlbertoBSD]

una matriz es básicamente un arreglo lineal asi que pe podría mandar algo asi:

En main si es una matriz bidimencional, pero como solo se pasa la referencia de la matriz y indicas los tamaños, solo es necesario pasar el apuntador a mostrar y mostrar lo maneja como un arreglo lineal, tratado como matriz.

Código (c) [Seleccionar] Expandir


#include<stdio.h>

void muestra(int *matriz, int renglon, int columna);

int main() {
int M, N, i, j;
scanf("%d %d", &M, &N);
int b_minas[M][N];
for (i= 0; i < M; i++) {
for (j= 0; j < N; j++) {
scanf("%d",&b_minas[i][j]);
}
}
muestra((int *) b_minas, M, N);
return 0;
}

void muestra(int *matriz, int renglon, int columna) {
printf("\n");
int i, j;
for (i= 0; i < renglon; i++) {
for (j= 0; j < columna; j++) {
printf("%d ", matriz[(i*columna) +j]);
}
printf("\n");
}
}


Salida:

Código [Seleccionar] Expandir


C:\codigos>matriz.exe
5 4
1
1
1
1
2
2
2
2
3
3
3
3
4
4
4
4
5
5
5
5

1 1 1 1
2 2 2 2
3 3 3 3
4 4 4 4
5 5 5 5



Saludos!

[MAFUS]

Veo que conoces malloc así que no hay problema en que uses memoria dinámica.
A la hora de generar el array házlo de forma dinámica.
El prototipo de la función que recibiera tu array sería éste:

Código [Seleccionar] Expandir

void muestra(int **array, int filas, int columnas);

Esto es así porqué si le pasas un array estático estás obligado a darle todas las dimensiones menos la de mayor peso. Esto es así porque C necesita conocer el tamaño de los objetos que va a usar, y cómo se escapa de la explicación de esta respuesta te lo tendrás que creer.

Ahora llega la hora de crear el array. Suponiendo que el número de filas ya está en n_filas y el número de columnas ya está en n_columnas, lo dimensionas de esta forma:

Código [Seleccionar] Expandir

int **mi_array = malloc(n_filas * sizeof(int*));

for(int i = 0; i < n_filas; ++i)
    mi_array[i] = malloc(n_columnas * sizeof(int));

A la hora de darle un dato a una posición cualquiera del array suponiendo m el número de fila, n el número de columna y x el dato a guardar:

Código [Seleccionar] Expandir

mi_array[m][n] = x;

Lo mismo que para mostrarlo:

Código [Seleccionar] Expandir

printf("%d", mi_array[m][n]);

Y a la hora de pasar el array a la función:

Código [Seleccionar] Expandir

muestra(mi_array, n_filas, n_columnas);

Ahora pensarás:
Pero si C necesita saber el tamaño de un objeto para poderlo usar ¿Por qué se le pasa mi_array sin dimensión alguna, en vez de hacer mi_array[][20], por ejemplo?

La respuesta es que todos los punteros tienen el mismo tamaño. Todos.

Así que te aseguras, de esta forma, que puedes pasarle a esta función un array con un tamaño arbitrario de sus dimensiones que te va a funcionar siempre que los valores que le pases a filas y columnas sean los que realmente tiene dicho array.

Muy importante, eso sí, cuándo dejes de utilizar el array debes liberarlo y eso se debe hacer desde dentro a afuera. Así:

Código [Seleccionar] Expandir

for(int i = 0; i < n_columnas; ++i)
    free(mi_array[i]);
free(mi_array);