Hola, espero no ser una molestia con los temas que abro cada poco tiempo.

Bueno, la cosa es que he tengo dos estructuras, y cuando reservo memoria para una de ellas creo que lo hago mal.


Aqui declaro las estructuras y defino MAX.


Aqui creo que reservo memoria, y pongo todo a NULL. Creo que aqui esta el fallo pero no se donde.



En esta libero la memoria, cuando compilo me da error al liberar la memoria, lo que me hace pensar que no reservo bien.


Aqui el main, la cosa es que cuando complio e inteto escribir sobrela variable x en tamanyo_mazmorra me da eror y el programa finaliza

Espero no ser de mucha molestia, un saludo  

Cuando depuro y llego a esta linea de codigo me da error y se termina el programa, eso me hace pensar que no puede acceder a esa zona de memoria y por ello creo que el problema esta al reservar la memoria. Creo que reservo mal.

El codigo que reserva la memoria es este:

Y mi duda es que al tener en la estructura una matriz de 20x20 no tendria que hacer un bucle o algo? como cuando se libera la memoria

---

He estado probando y he hecho esto para reservar memoria y parece que funciona, da warnings pero me deja acceder a las zonas para escribir y leer, pero me da error al intentar liberar memoria, lo que he hecho es esto:



Me podeis decir si eso que hice esta bien porfa

Te falta crear espacio (reservar memoria) para los punteros a struct Mazmorra dentro de _Punto.
Un saludo.

#include <stdio.h>
#include <stdlib.h>
#define MAX 20
 
typedef struct _Mazmorra {																			//Este struct tiene un tamaño de 2*int + 1*char
    int x;
    int y;
    char c;
 
}Mazmorra;
 
typedef struct _Punto{																					//Este struct tiene un tamaño de 4*Mazmorra
    Mazmorra *P_final;
    Mazmorra *P_principio;
    Mazmorra *p_tamanyo;
    Mazmorra *tamanyo_mazmorra[MAX][MAX];
}Punto;
 
Punto* inicializar_mazmorra(){
 
    Punto *punto;
    int x,y;
 
   punto=(Punto*)malloc(sizeof(Punto));														//Se crea espacio para un struct _Punto
   if(punto==NULL){
       printf ("error al reservar memoria");
   }
 
   punto->P_final = (Mazmorra *) malloc(sizeof(Mazmorra));				//Se crea espacio para un struct Mazmorra
   if(punto->P_final ==NULL){
       printf ("error al reservar memoria");
   }
   punto->P_final=NULL;
 
   punto->P_principio = (Mazmorra *) malloc(sizeof(Mazmorra));		//Se crea espacio para un struct Mazmorra
   if(punto->P_principio ==NULL){
       printf ("error al reservar memoria");
   }
   punto->P_principio=NULL;
 
   punto->p_tamanyo = (Mazmorra *) malloc(sizeof(Mazmorra));		//Se crea espacio para un struct Mazmorra
   if(punto->p_tamanyo ==NULL){
       printf ("error al reservar memoria");
   } 
   punto->p_tamanyo=NULL;
 
   for(x=0;x<MAX;x++){
       for(y=0;y<MAX;y++){
       	    punto->tamanyo_mazmorra[x][y] = (Mazmorra *) malloc(sizeof(Mazmorra));		//Se crea espacio para un struct Mazmorra
       	       if(punto->tamanyo_mazmorra[x][y] ==NULL){
    		   printf ("error al reservar memoria");
   				} 
            punto->tamanyo_mazmorra[x][y]=NULL;
       }
   }
 
   return punto;
}
 
void Liberarmemoria(Punto *punto) {
 
    int x,y;
 
    free(punto->P_final);
    free(punto->P_principio);
    free(punto->p_tamanyo);
       for(x=0;x<MAX;x++){
       for(y=0;y<MAX;y++){
            free(punto->tamanyo_mazmorra[x][y]);
       }
   }
 
}
 
int main(){
    FILE *archivo;
    Punto *punto;
    int x;    
 
    punto = inicializar_mazmorra();
 
    punto->tamanyo_mazmorra[1][1]->x = 5;
    archivo = fopen("prueba.dat","r");
    if(archivo==NULL){
        printf ("error");
    }
 
    printf ("%c",punto->tamanyo_mazmorra[1][1]->x);
 
    //x = leer_archivo_mazmorra(archivo,punto);
    Liberarmemoria(punto);
    fclose(archivo);
 
 
}