elhacker.net cabecera Bienvenido(a), Visitante. Por favor Ingresar o Registrarse
¿Perdiste tu email de activación?.

 

 


Tema destacado: (TUTORIAL) Aprende a emular Sentinel Dongle By Yapis


+  Foro de elhacker.net
|-+  Programación
| |-+  Programación C/C++ (Moderadores: Eternal Idol, Littlehorse, K-YreX)
| | |-+  Problemas con estructura anidada y archivos binarios
0 Usuarios y 1 Visitante están viendo este tema.
Páginas: [1] Ir Abajo Respuesta Imprimir
Autor Tema: Problemas con estructura anidada y archivos binarios  (Leído 523 veces)
Ergo

Desconectado Desconectado

Mensajes: 1


Ver Perfil
Problemas con estructura anidada y archivos binarios
« en: 30 Agosto 2019, 17:20 pm »

Hola. Soy nuevo en el foro y busco que alguien me eche una mano con un problema que tengo. Verán, estoy haciendo un modelo de examen. El cual tiene las siguientes estructuras:

Código
  1. typedef struct
  2. {
  3. char fecha[11];
  4. float notaParcial;
  5. }Parcial;
  6.  
  7. typedef struct
  8. {
  9. char nomAsignatura[60];
  10. int codAsignatura;
  11. float notaAsignatura;
  12. int numParciales;
  13. Parcial *parciales;
  14. }Asig;
  15.  
  16.  
  17. typedef struct
  18. {
  19. char nombre[100];
  20. char expediente[20];
  21. int numAsig;
  22. Asig *asignaturas;
  23. }Alumnos;


Estos datos se guardan en un árbol binario para posteriormente guardarlos en un Fichero binario. Hago lo siguiente:

Código
  1. void procesar(void *datos)
  2. {
  3.  
  4. Alumnos * A = (Alumnos*)datos;
  5. int i, j;
  6. FILE* pf;
  7. FILE *pf_lectura;
  8. pf = fopen("mifichero", "ab"); //abrimos modo append para añada al final cada
  9.  
  10. Alumnos *B = NULL;
  11. int resultado = 0;
  12.  
  13.  
  14.  
  15. if (pf != NULL)
  16. {
  17.  
  18. //Guardatos datos estaticos del alumno
  19. fwrite(A->nombre, sizeof(A->nombre),1, pf); //fwrite(que voy a grabar, tamaño del tipo de dato,  tamaño de datos vas a grabar?,archivo)
  20. fwrite(A->expediente, sizeof(A->expediente),1, pf);
  21. fwrite(&A->numAsig, sizeof(A->numAsig), 1, pf);
  22. //ahora grabamos datos de asignaturas y parciales
  23. for (i = 0; i < A->numAsig; i++) {
  24. fwrite(A->asignaturas[i].nomAsignatura, sizeof(A->asignaturas[i].nomAsignatura),1, pf);
  25. fwrite(&A->asignaturas[i].codAsignatura, sizeof(A->asignaturas[i].codAsignatura), 1, pf);
  26. fwrite(&A->asignaturas[i].notaAsignatura, sizeof(A->asignaturas[i].notaAsignatura), 1, pf);
  27. fwrite(&A->asignaturas[i].numParciales, sizeof(A->asignaturas[i].numParciales), 1, pf);
  28. //ahora grabamos los datos de los parciales
  29. for (j = 0; j < A->asignaturas[i].numParciales; j++) {
  30. fwrite(A->asignaturas[i].parciales[j].fecha, sizeof(A->asignaturas[i].parciales[j].fecha),1, pf);
  31. fwrite(&A->asignaturas[i].parciales[j].notaParcial, sizeof(A->asignaturas[i].parciales[j].notaParcial), 1, pf);
  32.  
  33. }
  34.  
  35. }
  36. fclose(pf);
  37.  
  38. }
  39.  
  40.  
  41. printf(">>>\t\t Imprimo Arbol>>>>\n\n");
  42.  
  43.  
  44.  
  45.  
  46. for (i = 0; i < A->numAsig; i++)
  47. {
  48.  
  49. printf("Nombre: %s\n", A->nombre);
  50. printf("Expediente: %s\n", A->expediente);
  51. printf("Numero de asignaturas: %d\n", A->numAsig);
  52.  
  53.  
  54. printf("Nombre de asignatura: %s\n", A->asignaturas[i].nomAsignatura);
  55. printf("Codigo de asignatura: %d\n", A->asignaturas[i].codAsignatura);
  56. printf("Nota de asignatura: %g\n", A->asignaturas[i].notaAsignatura);
  57. printf("Numero de parciales: %d\n", A->asignaturas[i].numParciales);
  58.  
  59. for (j = 0; j < A->asignaturas[i].numParciales; j++)
  60. {
  61.  
  62. printf("Fecha: %s\n", A->asignaturas[i].parciales[j].fecha);
  63. printf("Nota de parcial: %g\n", A->asignaturas[i].parciales[j].notaParcial);
  64.  
  65. }
  66. }
  67.  
  68.  
  69.  
  70.  
  71.  
  72.  
  73. //Leer fichero
  74.  
  75.  
  76. //Reservo memoria para leer datos
  77.  
  78. //Asignamos memoria para un objeto de tipo alumnos.
  79. B = (Alumnos*)malloc(sizeof(Alumnos));
  80.  
  81. //Reservo memoria para Asignaturas
  82. B->asignaturas = (Asig*)malloc(A->numAsig * sizeof(Asig));
  83.  
  84. for (i = 0; i < A->numAsig; i++)
  85. {
  86. //Reservo memoria para parciales
  87. B->asignaturas[i].parciales = (Parcial*)malloc(A->asignaturas[i].numParciales * sizeof(Parcial));
  88. }
  89.  
  90.  
  91. pf_lectura = fopen("mifichero", "rb");
  92.  
  93. if (!pf)
  94. printf("No se puede leer el fichero.\n");
  95.  
  96.  
  97.  
  98.  
  99. printf(">>>>\t\tImprimiendo datos desde el fichero binario.\n");
  100.  
  101. resultado += fread(B->nombre, sizeof(B->nombre), 1, pf_lectura);
  102. printf("Nombre: %s\n", B->nombre);
  103. resultado += fread(B->expediente, sizeof(B->expediente), 1, pf_lectura);
  104. printf("Expediente: %s\n", B->expediente);
  105. resultado += fread(&B->numAsig, sizeof(B->numAsig), 1, pf_lectura);
  106. printf("Numero de asignaturas: %d\n", B->numAsig);
  107.  
  108.  
  109. for (i = 0; i < B->numAsig; i++)
  110. {
  111.  
  112. resultado += fread(B->asignaturas[i].nomAsignatura, sizeof(B->asignaturas[i].nomAsignatura), 1, pf_lectura);
  113. printf("Nombre de asignatura: %s\n", B->asignaturas[i].nomAsignatura);
  114. resultado += fread(&B->asignaturas[i].codAsignatura, sizeof(B->asignaturas[i].codAsignatura), 1, pf_lectura);
  115. printf("Codigo de asignatura: %d\n", B->asignaturas[i].codAsignatura);
  116. resultado += fread(&B->asignaturas[i].notaAsignatura, sizeof(B->asignaturas[i].notaAsignatura), 1, pf_lectura);
  117. printf("Nota de asignatura: %g\n", B->asignaturas[i].notaAsignatura);
  118. resultado += fread(&B->asignaturas[i].numParciales, sizeof(B->asignaturas[i].numParciales), 1, pf_lectura);
  119. printf("Numero de parciales: %d\n", B->asignaturas[i].numParciales);
  120.  
  121. for (j = 0; j < B->asignaturas[i].numParciales; j++)
  122. {
  123. resultado += fread(B->asignaturas[i].parciales[j].fecha, sizeof(B->asignaturas[i].parciales[j].fecha), 1, pf_lectura);
  124. printf("Fecha: %s\n", B->asignaturas[i].parciales[j].fecha);
  125. resultado += fread(&B->asignaturas[i].parciales[j].notaParcial, sizeof(B->asignaturas[i].parciales[j].notaParcial), 1, pf_lectura);
  126. printf("Nota de parcial: %g\n", B->asignaturas[i].parciales[j].notaParcial);
  127.  
  128. }
  129.  
  130.  
  131. printf("Se han leido: %d bytes\n", resultado);
  132. fseek(pf_lectura, sizeof(resultado), SEEK_SET);
  133. }
  134.  
  135.  
  136.  
  137. fclose(pf_lectura);
  138. free(B);
  139.  
  140.  
  141.  
  142. }
  143.  


Con este código, si guardo una sola persona con todos sus datos, puedo leer el fichero son problemas. Pero cuando guardo más de uno... por ejemplo 2. Me imprime solo uno.
Lo muestro para que vean:


Introducir datos. Finlizar con eof.
--------------
Nombre de Alumno: ruben
Expediente: ruben
Numero de asignaturas: 1
Nombre de asignatura: ruben
Codigo de asignatura: 1
Numero de parciales realizados: 1
                         Fecha de parcial 1:    1
                         Nota de parcial 1:   1
Desea seguir agregando alumnos? (1-si/0-no)
1
--------------
Nombre de Alumno: juan
Expediente: juan
Numero de asignaturas: 1
Nombre de asignatura: juan
Codigo de asignatura: 1
Numero de parciales realizados: 1
                         Fecha de parcial 1:    1
                         Nota de parcial 1:   1
Desea seguir agregando alumnos? (1-si/0-no)

0


 Arbol:
>>>              Imprimo Arbol>>>>

Nombre: juan
Expediente: juan
Numero de asignaturas: 1
Nombre de asignatura: juan
Codigo de asignatura: 1
Nota de asignatura: 1
Numero de parciales: 1
Fecha: 1
Nota de parcial: 1
>>>>            Imprimiendo datos desde el fichero binario.
Nombre: juan
Expediente: juan
Numero de asignaturas: 1
Nombre de asignatura: juan
Codigo de asignatura: 1
Nota de asignatura: 1
Numero de parciales: 1
Fecha: 1
Nota de parcial: 1
Se han leido: 9 bytes
>>>              Imprimo Arbol>>>>

Nombre: ruben
Expediente: ruben
Numero de asignaturas: 1
Nombre de asignatura: ruben
Codigo de asignatura: 1
Nota de asignatura: 1
Numero de parciales: 1
Fecha: 1
Nota de parcial: 1
>>>>            Imprimiendo datos desde el fichero binario.
Nombre: juan
Expediente: juan
Numero de asignaturas: 1
Nombre de asignatura: juan
Codigo de asignatura: 1
Nota de asignatura: 1
Numero de parciales: 1
Fecha: 1
Nota de parcial: 1
Se han leido: 9 bytes
Presione una tecla para continuar . . .



¿Por qué solo me imprime a "juan" y no a "ruben" y cuál sería la manera correcta de poder imprimir mi fichero?
La manera en que se escribe el fichero es definida por el profesor, y me pide que lea el fichero.

Muchas gracias por la ayuda que puedan brindarme.


En línea

prof neurus

Desconectado Desconectado

Mensajes: 8



Ver Perfil
Re: Problemas con estructura anidada y archivos binarios
« Respuesta #1 en: 21 Septiembre 2019, 14:48 pm »

Me parece que estas leyendo el archivo solo el primer registro.

Debería ser algo como:

leer_registro
Mientras _no_sea_el_final_del_archivo {
    Operar
    leer_registro
}

Espero te ayude.


En línea

<Desde las primeras computadoras siempre hubo fantasmas en la máquina. Segmentos aleatorios de código que se agrupan para formar protocolos inesperados. Podría llamarse conducta. Radicales libres que engendran interrogantes de libre albedrío creatividad y hasta la naturaleza de lo que podría ser un alma./>
Páginas: [1] Ir Arriba Respuesta Imprimir 

Ir a:  

WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines