Autor Tema: Buscar string en un archivo, y obtener datos (Leído 4289 veces)

emma1990 · « **en:** Lunes 21 de Marzo de 2011, 23:30 »

Hola!

No me vendría mal un poco de ayuda con un programa que estoy haciendo

La historia consiste en que el programa abra un archivo de texto y busque una cadena, grabando lo que hay después de la cadena a otro archivo de texto.

Es decir, que si en el archivo input.txt hay esto: "blablabla nombre emma blablabla", obtenga un output.txt con el contenido "emma".

Soy bastante principiante en esto, pero sí sé abrir y cerrar archivos. Donde necesitaría ayuda es con lo demás

Alguna idea?

Gracias de antemano!

m0skit0

Lees el fichero línea por línea y usas strstr() para buscar una subcadena.

Saludos.

emma1990

Muchas gracias!
Voy a probar eso y te cuento
De todas formas, veo una pequeña dificultad... voy a saber leer el archivo y guardar cada línea a un string, y luego compararlo con mi string de búsqueda, pero.. cómo obtengo luego el dato que va después del string de búsqueda?

Gracias otra vez

m0skit0

Mírate la documentación de strstr(), haz el favor

emma1990

Cita de: "m0skit0"

Mírate la documentación de strstr(), haz el favor

Vale, con strstr() llego a saber que en el string "enunlugardelamancha", el string "la" está en la posición 12. Ahora, cómo hago para copiar un substring de ese string, "mancha", con las posiciones 14-19 del string "enunlugardelamancha"? Ese es mi problema.

strcpy() no parece servirme, o al menos no sé como copiar el substring que me interese sabiendo la posición de inicio.

Saludos

m0skit0

strcpy te sirve perfectamente, aunque yo siempre uso strncpy para evitar infernales bugs de desbordamientos de buffer (que además pueden comprometer la seguridad de tu programa).

Código: C

unsigned int pos; // Suponemos que aquí tienes guardada la posición en que se encuentra la subcadena
char* buscar; // Aquí la subcadena que buscas
char* cadena; // Aquí la cadena completa
char* resto; // Aquí es donde quieres almacenar el resto de la cadena
// Recuerda reservar la memoria y liberarla para todos estos punteros ;)
[...]
char* aux = (char*) ((unsigned int)cadena + pos + strlen(buscar));
strncpy(resto, aux, <tamaño de "resto">);
 

Ojo que tienes que reservar suficiente memoria para que en resto pueda caber todo lo que venga después de la subcadena.

emma1990

Al final lo fui haciendo sin strcpy(). Qué te parece esto? A lo mejor es un poco chapuzas pero para lo que quiero es funcional

Código: C

FILE *pf;
char cadena[100], linea[100], *ptr;
pf = fopen("file.txt", "r");
while (fgets(linea,100,pf) != NULL) { 
      fscanf(pf, "%s", &cadena);  
      ptr=strstr(linea, "Ki");
if (ptr!=0) printf("%c%c%c%c%cn", cadena[ptr-cadena+6], cadena[ptr-cadena+7], cadena[ptr-cadena+8], cadena[ptr-cadena+9], cadena[ptr-cadena+10]); 
}
fclose(pf);
getchar();
}
 

m0skit0

Un poco no, es MUY chapuzas. ¿Y qué pasa si la línea tiene más de 5 caracteres después del marcador? ¿Y por qué empiezas en +6?

De todas formas, si lo que quieres es mostrar el resto de la cadena, te vale con

Código: C

if (ptr != NULL) 
{
    printf("%sn", (char*)((unsigned int)ptr + strlen("Ki")));
}
 

- No pongas las condiciones del if seguidas, es poco legible, y usa siempre { }, te ahorrarás futuros quebraderos de cabeza.
- Usa NULL, no 0 (tampoco hagas !ptr)
- No uses literales en el código, usa constantes (#define)

Además ese código es muy poco flexible. Intenta programar de manera que si te toca modificar el código (y créeme que lo vas a tener que modificar) no tengas que mover cielo y tierra.

Amilius

De acuerdo con todo, especialmente con adoptar un estilo definido de programación.

Aunque personalmente prefiero este tipo de comparaciones para verificar punteros no nulos:

Código: C++

 
if (ptr)
{
}

Y para los nulos prefiero usar el 0, ¿Para que escribir 4 letras y ocultar lo que en realidad es un puntero nulo?

Código: C++

 
if (0 == ptr)
{
}

Tampoco me hago problema con un if en una sóla linea siempre y cuando sea más rápido de leer. En casos extremadamente simples es más rápido leer esto:

Código: C++

 
if (0 == ptr) return;

que esto:

Código: C++

 
if (0 == ptr) 
{
    return;
}

haddad

mmm creo que quede un poco confundida en cuanto al orden de soluciones que planteaste

Cita de: "m0skit0"

printf("%sn", (char*)((unsigned int)ptr + strlen("Ki")));

eso es la solucion a?

Cita de: "m0skit0"

- No pongas las condiciones del if seguidas, es poco legible, y usa siempre { }, te ahorrarás futuros quebraderos de cabeza.
- Usa NULL, no 0 (tampoco hagas !ptr)
- No uses literales en el código, usa constantes (#define)

m0skit0

Cita de: "Amilius"

Y para los nulos prefiero usar el 0, ¿Para que escribir 4 letras y ocultar lo que en realidad es un puntero nulo?

Porque es menos portable. Estás asumiendo que el puntero nulo tiene el valor 0, algo que en otras arquitecturas distintas de Intel no tiene por qué ser así. Por algo existe la constante NULL, que es dependiente de la arquitectura.

Cita de: "Amilius"

Tampoco me hago problema con un if en una sóla linea siempre y cuando sea más rápido de leer.

A mí me parece menos legible por el simple hecho de tener distintas estructuras de ifs en todo el programa. Prefiero poner todos los ifs iguales, no veo porqué hay que poner unos ifs de una forma y otros de otra, no ayuda a la legibilidad en mi opinión. Pero vamos, es cuestión de formas y gustos.

Cita de: "haddad"

printf("%sn", (char*)((unsigned int)ptr + strlen("Ki")));
eso es la solucion a?

Es parecido a

Código: C

printf("%c%c%c%c%cn", cadena[ptr-cadena+6], cadena[ptr-cadena+7], cadena[ptr-cadena+8], cadena[ptr-cadena+9], cadena[ptr-cadena+10]);
 

pero bien hecho

Leber

Hola moskito, compilando esto:

Código: C

 
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
 
int main(void)
{
    char line[] = "Hola que tal estas";
    char *ptr;
 
            ptr = strstr (line, "que");
            if(ptr != NULL) {
                printf("%sn", (char*) ((unsigned int)ptr + strlen("que")) );
            }
            return 0;
}
 

Me da un warning, y si lo ejecuto da segfault. Si entiendo bien, le estas diciendo "lo que contiene ptr" + "la longitud de que". Y por que se hace un cast a unsigned int? Siento tantas preguntas pero es que estaba leyendo esto ayer, y me pico la curiosidad.

Gracias de antemano

m0skit0

Perdona, lo había puesto sin probar.

Weno, acabo de ejecutar ese mismo programa y me funciona correctamente:

Código: Text

root@bt:~# cat prueba.c
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
 
int main(void)
{
    char line[] = "Hola que tal estas";
    char *ptr;
 
            ptr = strstr (line, "que");
            if(ptr != NULL) {
                printf("%sn", (char*) ((unsigned int)ptr + strlen("que")) );
            }
            return 0;
}
root@bt:~# gcc -o prueba prueba.c
root@bt:~# ./prueba
 tal estas
root@bt:~#
 

Leber

Pues, acabo de copiar tu codigo, y no funciona. Mira:

Código: C

test@sistemes-oscar:~/c$ cat prueba.c 
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
 
int main(void)
{
    char line[] = "Hola que tal estas";
    char *ptr;
 
            ptr = strstr (line, "que");
            if(ptr != NULL) {
                printf("%sn", (char*) ((unsigned int)ptr + strlen("que")) );
            }
            return 0;
}
test@sistemes-oscar:~/c$ gcc -o prueba prueba.c
prueba.c: In function ‘main’:
prueba.c:12: warning: cast from pointer to integer of different size
test@sistemes-oscar:~/c$ ./prueba 
Segmentation fault
test@sistemes-oscar:~/c$
 

Me resulta bastante extraño.
Lo mismo, si lo hago en SO de 32 bits, funciona:

Código: C

test@sistemes-test:~$ cat proba.c 
#include <stdio.h>
#include <string.h>
#include <stdlib.h>                                                                                                                                                                   
                                                                                                                                                                                      
int main(void)                                                                                                                                                                        
{                                                                                                                                                                                     
    char line[] = "Hola que tal estas";                                                                                                                                               
    char *ptr;                                                                                                                                                                        
                                                                                                                                                                                      
            ptr = strstr (line, "que");                                                                                                                                               
            if(ptr != NULL) {
                printf("%sn", (char*) ((unsigned int)ptr + strlen("que")) );
            }
            return 0;
}
 
test@sistemes-test:~$ ./proba 
 tal estas
test@sistemes-test:~$ 
 

En mi maquina, mi SO es de 64 bits, y no funciona, en esta ultima es de 32 bits y funciona. Ambas maquinas tienen la misma version del gcc 4.4.3.
No se ver muy claro por que en 32 si y en 64 no, lo unico que me viene a la cabeza es que los punteros en 64 bits ocupan 8 bytes en lugar de 4 como ocurre en 32, pero... esto no debería afectar en este codigo, no?

Gracias

m0skit0

Bueno, esto lo malo que tiene C, que es poco portable si te pones a hacer malabares con punteros y casts.

El problema radica efectivamente como dices en el tamaño del puntero y en el uso de unsigned int, que si no recuerdo mal tiene el mismo tamaño en 32 que en 64 bits, de ahí el warning del compilador de que se están sumando dos tipos de tamaños diferentes (warning: cast from pointer to integer of different size) y por tanto pierdes posiblemente medio puntero, con lo que la dirección a la que apunta ya no tiene nada que ver, de ahí la violación de segmento.

Creo que si pones unsigned long long te debería funcionar sin problemas (no puedo probarlo porque no tengo máquina de 64 bits).

Saludos

Leber

Efectivamente, 4 bytes se pierden con solo unsigned int. Aunque basta con ponert unsigned long int:

Código: C

int main(void)
{
    char line[] = "Hola que tal estas";
    char *ptr;
 
            printf("Size int-> %ldn", sizeof(unsigned int));
            printf("Size int-> %ldn", sizeof(unsigned long int));
 
            ptr = strstr (line, "que");
            if(ptr != NULL) {
                printf("%sn", (char*) ((unsigned long int)ptr + strlen("que")) );
            }
            return 0;
}
 
 
test@test:~/c$ ./prueba 
Size int-> 4
Size int-> 8
 tal estas
 

Igualmente, tengo otra duda, y es sobre:

Código: C

(char*) ((unsigned long int)ptr + strlen("que"))
 

Sobretodo esta parte:

Código: C

(unsigned long int)ptr
 

. Estas casteando la direccion de memoria, y le sumas 3, que es la longitud de la cadena.

Entonces, si la direccion de ptr empieza en "0x7fffd1573a20" le sumas 3 quedando: "0x7fffd1573a23"

Es correcto, o me estoy liando?

Saludos, y gracias por las respuestas =)

m0skit0

Cita de: "Leber"

Aunque basta con ponert unsigned long int

Ah, ok. En 32 bits y según mi experiencia sizeof(long) = sizeof(int)

Código: C

#include <stdio.h>
 
int main(void)
{
    printf("%d %dn", sizeof(int), sizeof(long));
    return 0;
}
 

de ahí que dijera long long

Cita de: "Leber"

Estas casteando la direccion de memoria, y le sumas 3, que es la longitud de la cadena.
Entonces, si la direccion de ptr empieza en "0x7fffd1573a20" le sumas 3 quedando: "0x7fffd1573a23"
Es correcto, o me estoy liando?

Exacto. Hago el cast para que el compilador entienda que no me he equivocado, que efectivamente quiero que a un puntero le sume un entero, pero que luego lo siga considerando un puntero. Y le sumo la longitud de la cadena para posicionarme al final de la cadena que se ha encontrado con strstr().

Ojo y repito que esto sólo funciona si quiero el resto de la cadena (desde la posición X hasta final de cadena). De otro modo que no sea hasta el final de la cadena habría que hacer un memcpy/strncpy en un buffer y añadirle el terminador de cadena antes de poder mostrarlo con printf (o cualquier otra función de manejo de cadenas).

Leber

Hola m0skito.

Si, entiendo que ese es el funcionamiento, que lo que quieres es:

Teniendo una cadena tal que asi: "hola que tal", y que strstr te devuelva un puntero a "que tal" (porque has buscado la primera aparicion de que), lo que le estas diciendo es:

Muestrame lo que sigue a partir de la posicion, p.e: 0x7fffd1573a23, (teniendo en cuenta que ptr apunte a 0x7fffd1573a20). Entonces recibes a partir de 0x7fffd1573a23 hasta final de linea.

Gracias por tu ayuda, me ha quedado bastante claro, y es algo que siempre he tenido algo así así, sabian lo que eran los punteros, pero no los habia manipulado de esta manera, no habia entendido nunca demasiado bien el desplazamiento que podias hacer a traves de la memoria, como ahora.

Saludos y gracias

m0skit0

Cita de: "Leber"

Entonces recibes a partir de 0x7fffd1573a23 hasta final de linea.

Bueno, para seguir hablando de posiciones de memoria, que muestre los caracteres desde 0x7fffd1573a23 hasta que encuentre un byte (o carácter) nulo.

No hay de qué, estamos aquí para compartir lo que sabemos, así que ya sabes, ahora te toca a ti compartir

Leber

Cita de: "m0skit0"

No hay de qué, estamos aquí para compartir lo que sabemos, así que ya sabes, ahora te toca a ti compartir

Intentaremos que así sea =)