Estoy ejecutando un programa con 3 estructuras y lo que estoy haciendo para leer/escribir en el archivo binario es la siguiente:

struct Medico
{
int Id_Doctor;
int Estado;
char Nombre[60];
char Clave_Acceso[20];
char Especialidad[40]; 
struct Medico *next;
};
typedef struct Medico *Medicazos;
typedef struct Medico Meds;
Medicazos Nuevo;
FILE *Archivaldo;
char especialida[40], password[20];
char nombre_doc[60];
int estado_doc, id_doc;
Archivaldo=fopen("md.dat", "rb");
fclose(Archivaldo);
if((Archivaldo=fopen("md.dat", "rb"))==NULL)
{
printf("No se pudo abrir el archivo de Medicos\n"); //couldnt open file msg
exit(1);
}
rewind(Archivaldo);
while(!feof(Archivaldo))
{
if(*Inicio != NULL)  //read from file and write in struct
{
Nuevo = (Medicazos) malloc (sizeof(Meds)); //new=pointer
fread(&id_doc, sizeof(int), 1, Archivaldo);
fread(nombre_doc, sizeof(char), sizeof(nombre_doc), Archivaldo);
fread(password, sizeof(char), 20 , Archivaldo);
fread(especialida, sizeof(char), 40, Archivaldo);
fread(&estado_doc, sizeof(int), 1, Archivaldo);
Nuevo->Id_Doctor=id_doc; ///copies data in structure
strcpy(Nuevo -> Nombre , nombre_doc);
strcpy(Nuevo -> Clave_Acceso, password);
strcpy(Nuevo -> Especialidad, especialida);
Nuevo-> Estado = estado_doc;
printf("---------------------------------\n"); //display info
printf("ID: %d\n", id_doc);
printf("\nDoctor: ");
puts(nombre_doc);
printf("\nPassword: ");
puts(password);
printf("\nEspecialidad: ");
puts(especialida);
printf("\nEstado: ");
if(estado_doc==1)
puts("Activo\n");
else
puts("Inactivo\n");
Nuevo-> next = *Inicio;
*Inicio = Nuevo;
}
else 
{
*Inicio = (Medicazos)malloc(sizeof(Meds));
fread(&id_doc, sizeof(int), 1, Archivaldo);
fread(nombre_doc, sizeof(char), sizeof(nombre_doc), Archivaldo);
fread(password, sizeof(char), 20 , Archivaldo);
fread(especialida, sizeof(char), 40, Archivaldo);
fread(&estado_doc, sizeof(int), 1, Archivaldo);
(*Inicio)->Id_Doctor=id_doc;
strcpy((*Inicio) -> Nombre , nombre_doc);
strcpy((*Inicio) -> Clave_Acceso, password);
strcpy((*Inicio) -> Especialidad, especialida);
(*Inicio)-> Estado = estado_doc;
printf("--------------------------------\n"); //display info
printf("ID: %d\n", id_doc);
printf("\nDoctor: ");
puts(nombre_doc);
printf("\nPassword: ");
puts(password);
printf("\nEspecialidad: ");
puts(especialida);
printf("\nEstado: ");
if(estado_doc==1)
puts("Activo\n");
else
puts("Inactivo\n");
(*Inicio) -> next = NULL;
}
}
fclose(Archivaldo);

Hay alguna forma de hacer simplificar esto?

EDITAR: También, cuando trato de mostrar los archivos alguien me mencionó que no uso feof mientras que para la lectura/escritura. No recuerdo por qué. Lo que podría ser utilizado en lugar de otro?

  • Por favor el formato del código.
  • Por favor, etiqueta a tus preguntas en el futuro con el idioma que está utilizando. Yo marcados con C porque parece que sólo está utilizando C.
  • Pensé que yo hice, lo siento; por cierto, cada vez me parecen formato el código cuando he puesto la cuestión no parece ser en formato..
  • ¿Por qué no serialise su estructura en algo como json y almacenarlos en el disco como un texto (en lugar de binario) de archivo. Iba a hacer la depuración más sencilla y archivos de texto, generalmente, son más manejables que los binarios.
  • Me gustaría loveeeee hacerlo en un archivo txt, pero estoy obligado a hacerlo en binario.
InformationsquelleAutor drodri420 | 2010-12-08

1 Comentario

  1. 28

    Estoy asumiendo que su estructura se parece a esto:

    struct Medicazos
    {
    char Nombre[60];
    char Clave_Acceso[20];
    char Especialidad[40];
    int Id_Doctor;
    int Estado;
    }

    Se pueden leer/escribir/copiar este tipo alrededor como una sola unidad. No hay necesidad de hacerlo por etapas de acceso hasta que esté preparado para el uso de los valores.

    struct Medicazos m = {"Bob", "Password", "Feet", 123, 456};
    FILE* f = fopen(...);
    fwrite(&m, sizeof(struct Medicazos), 1, f);

    Y el mismo (pero al revés) para fread.

    (Por cierto, su mayúsculas los nombres de las variables se me está matando.)

    • +1 para la limpieza respuesta y me gustaría poder darle otro +1 para el último comentario acerca de los nombres de las variables.
    • Supongo haciendo que el código no toma «endian» en cuenta?
    • Lo siento, pensé que he publicado de la estructura, la estructura es en la edición de la pregunta
    • no más de lo que la pregunta original.
    • Oh, yo no estoy tratando de ser polémica. «Endian» siempre termina me confunde. El problema sería escribir el archivo en un «little-endian» de la máquina y tratando de leer en un big-endian, ¿supongo?
    • yo tampoco, Literalmente, haciendo 5 freads en 5 campos de estructura o haciendo 1 fread en toda una estructura, endianness no afecta el resultado. Las estructuras de C, como matrices, siempre ascendente orden de los bytes. Las cadenas de caracteres no se ven afectados. Si la transferencia de un big endian máquina a little endian, los dos enteros que tendrían que tener sus bytes que se invierte (pero no se cambia el uno con el otro).
    • Schz, ahora que ha agregado a su estructura, debo señalar que tendrás que volver a vincular su lista después de la lectura. Direcciones de la memoria RAM, obviamente, no sobrevivirá a la escritura en el disco y volver a la lectura.
    • ¿Qué acerca de los punteros en la estructura? Me refiero a ¿qué pasa si la estructura tiene un puntero a una matriz (con ancho predefinido) o a otra estructura?
    • Que no era el OP pregunta. Esta pregunta/respuesta se acerca la simplificación binaria IO para la estructura de la definición. Su pregunta es diferente, y deberá solicitar una nueva pregunta.
    • Veo, gracias por la respuesta. Pensé que podría obtener una respuesta rápida de OP de la pregunta (si hay algún corto).
    • La respuesta más corta es que no se puede aplicar esta respuesta si no hay punteros en la estructura. Punteros almacenar direcciones de memoria, y no tendrá sentido si es por escrito y, a continuación, leer de un archivo.

Dejar respuesta

Please enter your comment!
Please enter your name here