cómo puedo guardar la estructura en el archivo .... C lang

Question

Me gustaría guardar una estructura en un archivo. Me gustaría realizar una función que hace que esto funcione. Intenté este código pero no funcionó.

struct utilisateur // enregestrement pour sauvegarder les details de l utilisateur 
{ 
char nom[20]; 
char prenom[20]; 
int place; 
char depart[20]; 
char arrive[20]; 
char sexe; 
int nwagon; 
}; 

struct utilisateur utilis; 
struct utilisateur *Table[48]; 

void crea_fich(struct utilisateur *Tutilis) 
// creation un fichier, vous introduiez le nom, et le sotcker par enreg 
{ 
    FILE *f; 
    if (f!==0) 
    { 
     printf("error in the name of file \n"); 
     exit(1); 
    } 
    if (f=fopen(futilis,"w")==Null){ 
     fprint("We can't creat file \n"); 
     exit(1); 
    } 
    else{ 
     f=fopen("futilis.dat","wb"); 
     fwrite(Tutilis ,sizeof(utilisateur),1,f); 
    } 
} 

Answer 1

me vería en los nombres de los símbolos en primer lugar, al igual que NULL y fprint, por no mencionar que raro \0. Como una idea adicional, debe cerrar el archivo después de escribir para asegurarse de que se vacíe en el disco, y verificar que la variable futilis es un char* que contiene una ruta válida y escribible.

Answer 2

No. Necesita escribir sus miembros de datos individualmente, uno a la vez. No debe copiar ciegamente la representación de memoria de su estructura en el búfer de salida de archivo (que está claro que está tratando de hacer). Escribir los archivos de esa manera hará que los archivos no sean portátiles (no serán legibles, excepto en la plataforma en que fueron escritos), debido a la endianancia y al relleno específico de la plataforma de los elementos de la estructura.

Answer 3

Sólo un ejemplo sencillo :)

// your struct 
struct Data 
{ 
    int first; 
    double second; 
    char third[10]; 
}; 

luego escribir la estructura!

struct Data data = {22, 4.0, "Hi"}; 
FILE* output; 

output = fopen("Data.dat", "wb"); 

fwrite(&data, sizeof(data), 1, output); 

fclose(output); 

¡Finalmente lea los datos del archivo que ha creado!

struct Data data; 
FILE* input; 

input = fopen("Data.dat", "rb"); 

fread(&data, sizeof(data), 1, input); 

// you got the data from the file! 

fclose(input); 

Los archivos binarios son pesadillas si no escritos y leídos prudentemente. Debe ocuparse de muchas cosas sobre la arquitectura donde se creó el archivo y dónde se leerá. Endianess y el tamaño de las variables son los más importantes. Además, si tiene punteros dentro de su struct, el puntero que se escribirá en el archivo no los datos reales a los que apunta el puntero. Lo sentimos, no editar el código, ya que está lleno de errores de compilación :)

He eliminado mi primera respuesta porque era tan malo, lo siento :)

Answer 4

Prueba esto, y luego si eso no es hacer lo Si lo desea, intente explicar cómo difiere de lo que desea.

void crea_fich(struct utilisateur *Tutilis) 
{ 
    FILE *f; 
    size_t nwritten; 

    f = fopen("futilis.dat","wb"); 

    if (f == NULL) 
    { 
     fprintf(stderr, "Cannot open file for writing.\n"); 
     exit(1); 
    } 

    nwritten = fwrite(Tutilis, sizeof Tutilis[0], 1, f); 
    fclose(f); 

    if (nwritten < 1) 
    { 
     fprintf(stderr, "Writing to file failed.\n"); 
     exit(1); 
    } 
} 

Answer 5

Michael S is right; usar fwrite con una estructura es muy poco portable. Pero supongamos que no te importa eso y quieres algo fácil de escribir que funcione.

El problema en su código es que se ha roto la regla de oro de sizeof: nunca use sizeof con un nombre de tipo. En su lugar, debe usar sizeof con un valor l, y casi siempre con la desreferencia de otro argumento. Por lo tanto,

Tutilis = malloc (sizeof (*Tutilis)); 
    ... 
fwrite(Tutilis, sizeof (*Tutilis), 1, f); 

Si sigue esta receta, es mucho más difícil obtener el tamaño incorrecto.

Answer 6

Me doy cuenta de que esta es una publicación anterior, pero aparece cuando la gente busca esta información, así que daré mi propia solución.

Esto es básicamente lo que he usado en uno de mis juegos. De hecho, tengo un código adicional de biblioteca adicional en mi propia función para diálogos, pero esto es esencialmente eso. Escribo datos individualmenteNo creo que tenga una estructura para estos datos, pero no hay diferencia, solo escriba los miembros de la estructura individual por separado. Como se mencionó, es mejor así.

// returns 1 if successful, 0 if not 
int savemap(const char *map_name) 
{ 
    FILE *file = NULL; 

    // open the file in write binary mode 
    file = fopen(map_name, "wb"); 

    // always check return values to see if it was opened okay 
    if(file == NULL) { 
     fprintf(stderr, "Error opening file for writing.\n"); 
     return 0; 
    } 

    // write file ID, version and pills 
    fwrite(MAP_ID, sizeof(char), strlen(MAP_ID)+1, file); 
    fwrite(&MAP_VER, sizeof(unsigned char), 1, file); 
    fwrite(&pills, sizeof(unsigned short), 1, file); 

    // write the map data (unsigned int map[315]) 
    fwrite(&map, sizeof(unsigned int), 315, file); 

    // never forget to close the file 
    fclose(file); 

    return 1; 
}