[SOLUCIONADO] Como iniciar una Matriz Dinamica en una Funcion???

[jordy48]

Hola buen dia tengan todos ustedes.

Veran, tengo que hacer una matriz del tamaño [2^n] x [n] y bueno, lo que hago es que paso la n a una funcion para inicializar; utilizo una matriz dinamica, entonces en main declaro una variable "int **mat" y le paso mat a la funcion. con esto esperaba conseguir la matriz nueva generada por referenciacion en main, sin embargo me lleve la sorpresa que no era asi, uso malloc en la funcion de generacion y el apuntador que me regresa malloc no lo consigue el apuntador de apuntador a mat

Paso directo al código:

Este fue mi primer código

Código C:

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
 
int newMatDin(int **mat, int tam){
    int i,j;
    long int tot = (long int)pow(2,tam); //tam = columnas (J); //tot = 2^col (I)
 
    mat = (int **) malloc(tot * sizeof(int*));
 
    if (mat == NULL)
        return -1;
    else 
        printf("Comprobamos nueva direccion %p\n", mat); //Vemos que ya apunta a una direccion
 
 
    for(i=0; i<tot; i++) {
        mat[i] = (int *) malloc(tam * sizeof(int)); 
        if (mat[i] == NULL)
            return -1;
    }
 
    for(i=0; i<tot; i++) {
        for(j=0; j<tam; j++) 
            mat[i][j] = 0;
    }
    return 0;       
}
 
 
//****MAIN
main() { //***TEST***
    int **mat = NULL;
    int n = 4, k=1, i,j, temp;
 
    temp = newMatDin(mat, n);
    if (temp == 0)  
        for(i=0; i<(int)pow(2,n); i++) {
            for(j=0; j<n; j++)
                printf("%d  - ", mat[0][0]); //Violacion de Segmento, ya que mat = NULL, porque?
            printf("\n");
        }
    else
        printf("ERROR AL GENERAR MATRIZ\n");
 
    //Se generó bien la matriz, sin embargo **mat sigue apuntando a NULL
    printf("**mat apunta a: %p", mat); // NULL  ---  Porque no apunta a la nueva dir dada en malloc??
}
 

Entonces en lo que le movia a las cosas que se me ocurrian hice este otro, donde paso la direccion del puntero de puntero MAT, y cuando se termina la ejecución de la función, MAT ya cuenta con la direccion que nos dió malloc. Sin embargo ya se me hace muy dificil el manejo de los apuntadores dentro de la funcion y ahora la "Violacion de Segmento" se genera dentro de la funcion


Aca mi segundo código:

Código C:

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
 
/** Generamos la matriz dinamica, todos los elementos en 0, 
 *  si hay error retorna -1, sino regresa 0.
 */
int newMatDin(int ***mat, int tam){
    int i,j;
    long int tot = (long int)pow(2,tam); //tam = columnas (J); //tot = 2^col (I)
 
    *mat = (int **) malloc(tot * sizeof(int*)); //No me da error
 
    if (*mat == NULL) //No hay problemas aca, ya tiene direccion
        return -1;
    else 
        printf("%p\n", *mat); 
 
 
    for(i=0; i<tot; i++) {
        *mat[i] = (int *) malloc(tam * sizeof(int)); //En la segunda iteracion es cuando hay problemas
        if (*mat[i] == NULL)
            return -1;
    }
 
    for(i=0; i<tot; i++) { //Ya no entra bien aca por los problemas anteriores
        for(j=0; j<tam; j++) 
            *mat[i][j] = 0;
    }
    return 0;       
}
 
 
 
//******
main() {
    int **mat = NULL;
    int n = 4, k=1, i,j, temp;
 
    printf("MAT: %p\n",mat); //Apunta a NULL
    temp = newMatDin(&mat, n); //Creamos la matriz
    printf("MAT: %p\n",mat); //Apunta a la direccion asigana por MALLOC
 
    //Ya tengo bien el apuntador a la matriz dinamica inicializada en 0s solo que
    //adentro de la funcion hay problemas y no termina el resto bien
 
    printf("%d\n\n", **mat); // ERROR: Violacion de Segmento
 
 
}
 

Algun experto en el tema que pueda ayudarme?


Gracias

[vosk]

"...Algun experto en el tema que pueda ayudarme?..."

Bueno no soy un experto pero te puedo echar un cable :))

Tienes que trabajar con la referencia tanto en la llamada como en las asignaciones de la funcion:

Código C:

void nueva(int **mat) {
    int i;
 
    *mat = malloc(2 * sizeof(int *));
    for(i=0;i<2;i++){
        (*mat)[i] = malloc(2 * sizeof(int *));
    }
}
 

Y para la llamada envias la referencia:

Código C:

int **matriz = 0;
nueva(&matriz);
 

Alternativamente puedes crear una funcion que retorne el nuevo bloque de memoria:

Código C:

int **nueva() {
    int **mat, i;
 
    if(!(mat = malloc(2 * sizeof(int *)))) {
        return 0;
    }
    for(i=0;i<2;i++){
        if(!(mat[i] = malloc(2 * sizeof(int *)))) {
            return 0;
        }
    }
 
    return mat;
}
 

En este segundo metodo la llamada retorna el nuevo bloque:

Código C:

int **matriz = 0;
matriz = nueva();
 

Lo del los valores de retorno es una buena practica; normalmente se usa el 0 como finalizado sin error, y >0 como indice de error.

En cualquier caso recuerda que para cada malloc necesitas un free.

Saludos
vosk

[jordy48]

Muchisimas gracias vosk!!!

ya tenia tiempo que había visto tu respuesta pero estaba tan apretado (sigo) con las tareas de la universidad.

En verdad me ha servido grandemente tu respuesta y era exactamente lo que necesitaba, solo que tengo el detalle que con free no se libera del todo la memoria, pero bueno algo es algo.


Una duda, en el primer bloque de código que pones, no debería la función de recivir a la matriz como (int ***mat) ??? Creo que ese es el único detalle

Y bueno tambien pensé en eso que dices de una función que retorne el bloque de memoria pero me gustaba mas la idea de retornar 0 o -1 (me acostumbre a usar -1 cuando comense a usar el sistema y declarabamos PIDs)


Pero en fin.

Nuevamente, muchas gracias!

[vosk]

"...solo que tengo el detalle que con free no se libera del todo la memoria..."

Correcto, tal como te comenté para cada malloc necesitas un free, es decir que cada elemento que reservas con malloc necesitas liberarlo con free; dicho de otra forma, una matriz de 'y' por 'x', ejecutas 1 malloc para reservar las 'y' filas y para cada fila ejecutas un malloc para las 'x' columnas, eso es que necesitas (1+y) mallocs para reservar y (y+1) free para liberar. En el ejemplo que te puse y=2, luego se ejecutan 1+2 mallocs y por lo tanto se requieren los mismos free; algo de codigo:

Código C:

void nueva(int **mat, int fil, int col) {
    int i, mallocs = 0;
 
    *mat = malloc(col * sizeof(int *));
    mallocs++;
 
    for(i = 0; i < col; i++){
        (*mat)[i] = malloc(fil * sizeof(int *));
        mallocs++;
    }
 
    printf("Ejecuto %d mallocs\n", mallocs);
}
 
 
void libera(int **mat, int fil, int col) {//aquí solo sirve el nº de columnas
    int i, frees = 0;
 
    for(i = 0; i < col; i++) {
        free((*mat)[i]);
        frees++;
    }
 
    free((*mat));
    frees++;
    *mat = 0;
 
    printf("Ejecuto %d frees\n", frees);
}
 

Y ahora las llamadas para crear y liberar la matriz:

Código C:

int **matriz = 0;
 
nueva(&matriz, 2, 3);
libera(&matriz, 2, 3);
 

En este caso el numero de llamadas es nº de filas + 1 porque primero reservo las filas (y), y para cada fila las columnas (x); puedes cambiar la forma de implementar: puedes crear primero las columnas y para cada columna reservas las filas, entonces el nº de llamadas a malloc y free serán el nº de columnas + 1. Este orden es importante a la hora de recorrer la matriz y a la hora de liberarla (excepto para matrices cuadradas, pero incluso en esas tiene que quedar claro que son las filas y que son las columnas).


"...Una duda, en el primer bloque de código que pones, no debería la función de recivir a la matriz como (int ***mat) ???..."

Si y no me había dado cuenta; en este caso compila bien porque quiero que genere memoria en el puntero que le envio y da igual *** que ** (es un puntero vacío), pero no es correcto porque no representa lo que indica (un puntero a un doble puntero vacio pero que terminará siendo un puntero a un puntero de punteros). Creo que si tienes que presentarlo ante algun profesor mejor pongas *** tal como tu comentas.


"...Y bueno tambien pensé en eso que dices de una función que retorne el bloque de memoria pero me gustaba mas la idea de retornar 0 o -1..."

Ok es una buena opcion, excepto que te será mas util declarar 0 como ok y >0 como error; observa en siguiente ejemplo:

Código C:

typedef unsigned int ERRCHK;
enum ERROR_CODES {
    ERROR_SUCCESS,
    ERROR_NOMEM,
    ERROR_COUNT
};
static char *ERROR_STRINGS[ERROR_COUNT] = {
    "OK",
    "Memoria insuficiente para la operacion"
};
 
ERRCHK ejecuta() {
    if(hay un error) {
        return ERROR_NOMEM;
    }
    return ERROR_SUCCESS;
}
 
int main() {
    ERRCHK errcode;
 
    if((errcode = ejecuta())) {
        printf("Se produjo un error: %s", ERROR_STRINGS[errcode]);
    }
    ...
}
 

Esto es lo que suele usarse en las librerias que llevan la funcion de get_last_error o get_last_error_message; como ves con nº negativos no puedes usar el contador para iniciar el char *[] (puedes contarlo manualmente pero no es lo mismo).

Saludos
vosk