Tema: Segfault con una función que funciona en otro lugar
Ver Mensaje Individual
  #1 (permalink)  
Antiguo 28/08/2012, 12:38
Amphoth3ra
 
Fecha de Ingreso: mayo-2011
Mensajes: 26
Antigüedad: 13 años, 6 meses
Puntos: 1
Segfault con una función que funciona en otro lugar
El contexto es el siguiente: A partir de un archivo de antecedentes que guarda un identificador de un alumno, que a su vez guarda un identificador de un centro educativo, lo que estoy haciendo es un ranking de centros educativos en los que tienen más delitos cometidos con sus alumnos.

Para ello me propuse crear un archivo temporal, que está ordenado decrecientemente en torno al conteo de los centros que tienen más delitos de sus alumnos. Así a medida que se revisa el archivo de antecedentes, el archivo de conteo crece y se edita contantemente hasta obtener un ranking ordenado, del cual solo al final tendré que mostrar el resultado por pantalla.

La inserción y edición funcionan bien, pero mis problemas van cuando la función que me permite mostrar por pantalla el archivo de conteo (RevisarConteo), la quiero pasar al final (suena lógico porque no voy a estar mostrando constantemente por pantalla como se hace el ranking, solo lo voy a mostrar una vez), en ese caso al ejecutar (gcc) me sale un segfault.

Código C: 
Ver original
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4.  
  5. struct stAntecedente {
  6.    char rut_alumno[12];
  7.    int id_documento;
  8.    char sentencia[30];
  9.    int id_delito;
  10.    char fecha[12];
  11.    char rut_polichile[12];
  12. };
  13.  
  14. struct stAlumno {
  15.    char rut_alumno[12];
  16.    char nombre[30];
  17.    int edad;
  18.    int id_institucion;
  19. };
  20.  
  21. struct stCentroEduc {
  22.    int id_institucion;
  23.    char nombre[30];
  24. };
  25.  
  26. struct stRegistroConteo {
  27.    int cuenta;
  28.    char nombre_institucion[30];
  29. };
  30.  
  31. void RevisarConteo()
  32. {
  33.    /* Revisa el ranking archivado */ 
  34.    struct stRegistroConteo reg_conteo;
  35.    FILE *file_conteo;
  36.    file_conteo = fopen("conteo.dat", "r+b"); 
  37.  
  38.    while (fread(&reg_conteo, sizeof(struct stRegistroConteo), 1, file_conteo))
  39.    {
  40.    printf("%4d %-10s\n", reg_conteo.cuenta, reg_conteo.nombre_institucion);
  41.    }
  42.  
  43.    fclose(file_conteo);
  44. }
  45.  
  46. void InsertarNuevoConteo (struct stRegistroConteo new_conteo)
  47. {  
  48.    /* El archivo conteo emula un ranking de las instituciones cuyos delitos de sus alumnos más figuran en los antecedentes 
  49.       en otras palabras, el archivo está ordenado por la clave de cuenta en orden decreciente */
  50.    struct stRegistroConteo conteo_temp;
  51.    int insertado = 0;
  52.    FILE *file_conteo, *file_conteotemp;
  53.    file_conteo = fopen("conteo.dat", "r+b");  
  54.    if(!file_conteo) 
  55.      file_conteo= fopen("conteo.dat", "w+b"); 
  56.    file_conteotemp = fopen("conteotemp.dat", "r+b");  
  57.    if(!file_conteotemp) 
  58.      file_conteotemp = fopen("conteotemp.dat", "w+b"); 
  59.  
  60.    while (fread(&conteo_temp, sizeof(struct stRegistroConteo), 1, file_conteo)) 
  61.      {
  62.     if ((new_conteo.cuenta > conteo_temp.cuenta) && insertado==0)
  63.     {
  64.      fwrite(&new_conteo, sizeof(struct stRegistroConteo), 1, file_conteotemp);
  65.      fwrite(&conteo_temp, sizeof(struct stRegistroConteo), 1, file_conteotemp);
  66.          insertado=1;
  67.     }
  68.     else
  69.     {
  70.      fwrite(&conteo_temp, sizeof(struct stRegistroConteo), 1, file_conteotemp);
  71.     }
  72.             
  73.     } 
  74.  
  75.     if (insertado==0)
  76.     fwrite(&new_conteo, sizeof(struct stRegistroConteo), 1, file_conteotemp);
  77.  
  78.      fclose(file_conteo);
  79.      fclose(file_conteotemp);
  80.  
  81.      remove ("conteo.dat");
  82.      rename ("conteotemp.dat", "conteo.dat");
  83. }
  84.  
  85. void ConteoGeneral (char nombre_institucion[30])
  86. {
  87.   /* Esta función procederá en general a hacer el escrutinio de cada institución de cada alumno
  88.      en el archivo de antecedentes */
  89.   int encontrado = 0;
  90.   int conteo;
  91.   struct stRegistroConteo regi_conteo;
  92.   FILE *file_conteo, *file_conteotemp;
  93.   file_conteo = fopen("conteo.dat", "r+b");
  94.   if(!file_conteo)
  95.     file_conteo = fopen("conteo.dat", "w+b");
  96.  
  97.    /* Así por cada institución buscamos en el archivo de conteo: */
  98.    while (fread(&regi_conteo, sizeof(struct stRegistroConteo), 1, file_conteo))
  99.    {    if (!strcmp(regi_conteo.nombre_institucion, nombre_institucion)) 
  100.          encontrado = 1;
  101.    }
  102.  
  103.    fclose(file_conteo);
  104.  
  105.    /* Si no está la institución, la insertamos inmediatamente como nueva... */
  106.    if (encontrado==0)
  107.    {
  108.     strcpy(regi_conteo.nombre_institucion, nombre_institucion);
  109.         regi_conteo.cuenta = 1;
  110.         InsertarNuevoConteo(regi_conteo);
  111.    }
  112.    
  113.    /* ...pero si está, se debe borrar la institución del archivo original y reinsertarse con su conteo sumado en 1 */
  114.    else
  115.    {
  116.        file_conteo = fopen("conteo.dat", "r+b");
  117.        if(!file_conteo) 
  118.      file_conteo = fopen("conteo.dat", "w+b");
  119.        file_conteotemp = fopen("conteotemp.dat", "r+b");
  120.        if(!file_conteotemp) 
  121.      file_conteotemp = fopen("conteotemp.dat", "w+b");
  122.  
  123.        while (fread(&regi_conteo, sizeof(struct stRegistroConteo), 1, file_conteo))
  124.     {   
  125.  
  126.     if (strcmp(nombre_institucion, regi_conteo.nombre_institucion))
  127.         fwrite(&regi_conteo, sizeof(struct stRegistroConteo), 1, file_conteotemp);
  128.         else
  129.         conteo = regi_conteo.cuenta +1;
  130.         
  131.         }
  132.  
  133.         fclose(file_conteo);
  134.         fclose(file_conteotemp);
  135.  
  136.         remove ("conteo.dat");
  137.         rename ("conteotemp.dat", "conteo.dat");
  138.  
  139.         strcpy(regi_conteo.nombre_institucion, nombre_institucion);
  140.         regi_conteo.cuenta = conteo;
  141.         InsertarNuevoConteo(regi_conteo);
  142.    }    
  143.  
  144. }
  145.  
  146. void BuscarCentro (int temp_idinstitucion)
  147. {
  148.    /* Por cada alumno se busca el centro educacional al que pertenece */
  149.    struct stCentroEduc regi_centro;
  150.    FILE *file_cen;
  151.    file_cen = fopen("centros.dat", "r+b");          
  152.    if(!file_cen) 
  153.     file_cen = fopen("centros.dat", "w+b");
  154.  
  155.    while (fread(&regi_centro, sizeof(struct stCentroEduc), 1, file_cen))
  156.    {    
  157.     if (temp_idinstitucion==regi_centro.id_institucion)
  158.     
  159.         {
  160.         fclose(file_cen);
  161.         ConteoGeneral(regi_centro.nombre);  
  162.         }
  163.    }
  164. }
  165.  
  166. void BuscarAlumno (char temp_rutalumno[12])
  167. {
  168.    /* Por cada registro en el archivo de antecedentes busca un alumno */
  169.    struct stAlumno regi_alumno;
  170.    FILE *file_alu;
  171.    file_alu = fopen("alumnos.dat", "r+b");          
  172.    if(!file_alu) 
  173.     file_alu = fopen("alumnos.dat", "w+b");
  174.  
  175.    while (fread(&regi_alumno, sizeof(struct stAlumno), 1, file_alu))
  176.    {    
  177.     if (!strcmp(temp_rutalumno, regi_alumno.rut_alumno))
  178.     
  179.         {
  180.         fclose(file_alu);
  181.         BuscarCentro(regi_alumno.id_institucion);   
  182.         }
  183.    }
  184. }
  185.  
  186. int main()
  187. {
  188.    /* Función principal: Revisa el archivo de antecedentes */
  189.    struct stAntecedente regi_antecedente;
  190.    FILE *file_ant;
  191.    file_ant = fopen("antecedentes.dat", "r+b");          
  192.    if(!file_ant) 
  193.     file_ant = fopen("antecedentes.dat", "w+b");
  194.    rewind(file_ant);
  195.    printf("------------------------\n");
  196.    printf("*********\n");
  197.    printf("------------------------\n"); 
  198.    while  (fread(&regi_antecedente, sizeof(struct stAntecedente), 1, file_ant))
  199.     BuscarAlumno (regi_antecedente.rut_alumno);
  200.    RevisarConteo();   
  201.    printf("\n");
  202.    fclose(file_ant);
  203.    remove("conteo.dat");
  204. }

Sin embargo, cuando la función la paso a la función que me irá a buscar por cada alumno a su centro educativo, esta funciona, aunque con un loop por la búsqueda en el archivo de antecedentes.

¿Alguna idea de qué estaré cometiendo mal?

Saludos!