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.
#include <stdio.h>
#include <stdlib.h>
#define MAX 20
typedef struct _Mazmorra {
int x;
int y;
char c;
}Mazmorra;
typedef struct _Punto{
Mazmorra *P_final;
Mazmorra *P_principio;
Mazmorra *p_tamanyo;
Mazmorra *tamanyo_mazmorra[MAX][MAX];
}Punto;
Aqui creo que reservo memoria, y pongo todo a NULL. Creo que aqui esta el fallo pero no se donde.
Punto* inicializar_mazmorra(){
Punto *punto;
int x,y;
punto=(Punto*)malloc(sizeof(Punto));
if(punto==NULL){
printf ("error al reservar memoria");
}
punto->P_final=NULL;
punto->P_principio=NULL;
punto->p_tamanyo=NULL;
for(x=0;x<MAX;x++){
for(y=0;y<MAX;y++){
punto->tamanyo_mazmorra[x][y]=NULL;
}
}
}
En esta libero la memoria, cuando compilo me da error al liberar la memoria, lo que me hace pensar que no reservo bien.
Punto* 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]);
}
}
}
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
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);
punto = Liberarmemoria();
fclose(archivo);
}
Espero no ser de mucha molestia, un saludo :)
Trata de depurar tu programa; estas accediendo y liberando punteros nulos, tenes que asignarle memoria dinamica a esos punteros.
Cuando depuro y llego a esta linea de codigo me da error punto->tamanyo_mazmorra[1][1]->x = 5; 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:
Punto *punto;
punto=(Punto*)malloc(sizeof(Punto));
if(punto==NULL){
printf ("error al reservar memoria");
}
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:
punto->P_final=(Punto*)malloc(sizeof(Punto));
punto->P_principio=(Punto*)malloc(sizeof(Punto));
punto->p_tamanyo=(Punto*)malloc(sizeof(Punto));
for(x=0;x<MAX;x++){
for(y=0;y<MAX;y++){
punto->tamanyo_mazmorra[x][y]=(Punto*)malloc(sizeof(Punto));
}
}
Me podeis decir si eso que hice esta bien porfa
Esta mal en un detalle, los miembros de Punto son de tipo Mazmorra, no Punto.
Los warning son utiles, tenes que leerlos al menos, por ejemplo:
warning C4700: uninitialized local variable 'punto' used
En la funcion Liberarmemoria usas punto, un puntero indefinido, es logico que falle. Lo logico seria que esa funcion recibiera como parametro el Punto a liberar ...
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);
}