• Sábado 14 de Diciembre de 2024, 10:32
« anterior próximo »
Páginas: [1]

Autor Tema:  ¿problema Al Buscar Una Cadena Dentro De Otra?  (Leído 1528 veces)

Zambullo

  • Nuevo Miembro
  • *
  • Mensajes: 2
    • Ver Perfil
¿problema Al Buscar Una Cadena Dentro De Otra?
« en: Viernes 18 de Abril de 2008, 00:04 »
0
Buenas, soy un novatillo en esto, así que no sé si la duda es un poco ridícula, pero es que ya no sé qué más probar  :( . El título lo pongo como pregunta porque no sé si el problema es con el strstr o quizá es porque no domino bien los punteros, pero no entiendo por qué este código no hace lo que debiera. En principio, el ejercicio hay que hacerlo de dos formas: en la primera se vuelca en memoria el texto de un archivo y se busca una palabra que pueda estar contenida en ese texto. En el otro caso, se lee directamente de un archivo y se busca si una palabra se encuentra en el texto del archivo. Éste último es el que no me funciona, pongo el código:

Código: Text
  1.  
  2.  
  3. /* -------------------------------*/
  4. /*           grep_rw              */
  5. /*                                */
  6. /* Búsqueda de una cadena en      */
  7. /* varios archivos con la técnica */
  8. /* read/write                     */
  9. /*--------------------------------*/
  10.  
  11. #include <stdio.h>
  12. #include <string.h>
  13. #include <stdlib.h>
  14. #include <fcntl.h>
  15. #include <sys/time.h>
  16.  
  17. int grep_rw (char *cadena, char *archivo) {
  18.  
  19.   int descriptor, valor_lectura, linea=1, linea_vista=0, interruptor=0, i= 0;
  20.   char letra[1], candidata[1024] = "";
  21.   // Nos servimos de la estructura timeval de sys/time.h para guardar los tiempos del principio y fin de ejecución:
  22.   struct timeval ti, tf;
  23.  
  24.   // Tomamos el tiempo antes de empezar las operaciones.
  25.   gettimeofday (&ti, NULL);
  26.  
  27.   // Abrimos fichero.
  28.   descriptor = open(archivo, O_RDONLY);
  29.  
  30.   // Comprobamos si el fichero se ha abierto correctamente.
  31.   if (descriptor == -1) {
  32.      printf("\n-> Error al abrir [%s]", archivo);
  33.      return (0);
  34.      }
  35.   else
  36.      printf("\n-> [%s] abierto correctamente.", archivo);
  37.  
  38.   // Empezamos a leer el fichero:
  39.   valor_lectura = read (descriptor, (char *)letra, 1);
  40.  
  41.   // Comprobamos si ha leído correctamente. Si es así, seguimos leyendo.
  42.   if (valor_lectura == -1)
  43.      printf("\n-> Error al leer [%s]\n", archivo);
  44.   else {
  45.      printf("\n-> Lectura de [%s] correcta.\n", archivo);
  46.          while (valor_lectura > 0) { // Mientras no se acabe el fichero...
  47.      while (letra[0] != '\n') { // Mientras la letra leída no sea un salto de línea...
  48.            // Concatenamos lo que llevamos leído de la línea con la nueva letra leída.
  49.             //i ++;
  50.       sprintf (candidata, "%s%s", candidata, letra);
  51.       valor_lectura = read (descriptor, (char *)letra, 1);
  52.     }
  53.       printf("%s\n", candidata);
  54.            // Comprobamos si la línea candidata que llevamos leída contiene la cadena buscada, y también si ya lo hemos comprobado con esa misma línea.
  55.            //candidata[i+1] = '\0';
  56.       if ((strstr(candidata, cadena) != NULL) && (linea != linea_vista)) {
  57.         interruptor = 1;
  58.         printf("Lalalalalalallal\n");
  59.         printf("\n[%s] está en la línea %d", cadena, linea);
  60.         linea_vista = linea;
  61.       }
  62.            // Seguimos leyendo el fichero.
  63.           // valor_lectura = read (descriptor, (char *)letra, 1);
  64.            //}
  65.     //i = 0;
  66.     linea ++;
  67.     valor_lectura = read (descriptor, (char *)letra, 1);
  68.     // Iniciamos a nada el valor de la línea candidata en la que después buscaremos la cadena.
  69.     candidata[0] = '\0';
  70.     }
  71.   // En caso de que no se haya encontrado ninguna vez la cadena:
  72.   if (interruptor == 0)
  73.   printf("\nNo se ha encontrado la palabra buscada en el archivo %s\n", archivo);
  74.   }
  75.   // Cerramos el fichero y comprobamos si se ha hecho correctamente.
  76.   close(descriptor);
  77.    if (descriptor==-1) {
  78.      printf("\n\n-> ERROR. [%s] no se ha cerrado correctamente\n",archivo);
  79.      return (0);
  80.      }
  81.   else
  82.      printf("\n\n-> [%s] cerrado correctamente\n",archivo);
  83.  
  84.   // Volvemos a tomar el tiempo después de las operaciones y devolvemos un valor de la función igual a la diferencia entre el tiempo inicial y el final (en microsegundos).
  85.   gettimeofday (&tf, NULL);
  86.   return ((tf.tv_sec * 1000000 + tf.tv_usec) - (ti.tv_sec * 1000000 + ti.tv_usec));
  87. }
  88.  

Este grep_rw es llamado por grep, que también dejo aquí, por si hiciese falta:

Código: Text
  1.  
  2. /* -----------------------------*/
  3. /*             grep             */
  4. /*                              */
  5. /* Versión reducida de la orden */
  6. /* grep de UNIX                 */
  7. /*------------------------------*/
  8.  
  9. #include <stdio.h>
  10. #include <string.h>
  11. #include <stdlib.h>
  12.  
  13. int main(int argc, char *argv[]) {
  14.  
  15.   int i, tiempo_rw, tiempo_mmap;
  16.  
  17.   // Comprobamos si el número de argumentos es el esperado.
  18.   if (argc < 3)
  19.      printf("-> ERROR: FALTAN ARGUMENTOS (grep <cadena> >nombre_fichero/s>)\n");
  20.   else {
  21.      // A partir del segundo argumento, empezamos a leer tantos ficheros como se hayan pasado.
  22.      for (i = 2; i != argc; i ++) {
  23.     printf("\nVa a comenzar la búsqueda de la cadena [%s] en el archivo [%s] por el método de grep_rw...", argv[1], argv[i]);
  24.     // Llamamos a grep_rw y guardamos su resultado.
  25.     tiempo_rw = grep_rw (argv[1], argv[i]);
  26.  
  27.     printf("\nVa a comenzar la búsqueda de la cadena [%s] en el archivo [%s] por el método de grep_mmap...", argv[1], argv[i]);
  28.     // Llamamos a grep_mmap y guardamos su resultado.
  29.     tiempo_mmap = grep_mmap (argv[1], argv[i]);
  30.     // Escribimos por pantalla el tiempo que ha tardado cada implementación en realizar sus operaciones sobre el mismo archivo.
  31.     printf("\n\nTiempo (microsegundos) necesario para ejecutar %s\n\n",argv[i]);
  32.     printf("grep_rw   : %d\n",tiempo_rw);
  33.     printf("grep_mmap : %d\n\n",tiempo_mmap);
  34.     getchar();
  35.     }
  36.   }
  37.   return(0);
  38. }
  39.  

Gracias de antemano.
Páginas: [1]
« anterior próximo »