Posicionarse en el registro inicial después de una búsqueda [C]

[rdv316]

Hola gente.
Una consultita más sobre archivo, estoy en la parte de modificación de un registro y lo que hace el programa es verificar si la nueva palabra ingresada en inglés no exista, para eso tengo que recorrerlo hasta que encuentre la palabra o hasta el final, cuando termina la verificación tengo que regresar nuevamente al registro original para por ej. Si se desea grabar la modificación no escriba en cualquier lugar sino en el registro correcto.-
Concretamente la pregunta es: ¿Cómo guardo el registro antes de la búsqueda? , intentaría con el siguiente código pero no estoy seguro si es lo correcto.-

Código:

    ..........................
     long tam;
	
     tam=sizeof(trad);
     fseek(ptrFile, 0, SEEK_END);
     registros=ftell(ptrFile)/tam;	
     ...........................

El código no lo pongo porque tiene 251 líneas y me parece que no es necesario.-
Saludos.
Daniel

[vangodp]

A ver si te sirve... Si lo ves complicado te explico lo que tengas duda XD

Código C:

#include <stdio.h>
#include <string.h>
#include <windows.h>
 
typedef struct {
    char marcado;
    char ingles[30];
    char espaniol[30];
} Traductor;
 
int main () {
    FILE* ptrFile;
    ptrFile = fopen ( "archivo.txt", "w+" );
    char buscado[30];
 
    if ( ptrFile == NULL ) {
        printf ( "No ha sido posible abrir archivo.txt" );
        return 1;
    }
 
    Traductor temp;
    Traductor t[5] = {
        { 0, "door", "puerta"},
        { 0, "window", "ventana"},
        { 0, "rueda", "wheel"},
        { 0, "main", "principal"},
        { 0, "out", "salida"}
    };
    //Nos genera un archivo con el contenido de t ya que abrimos con el atributo w+, asi nos centramos
    //solo en su funcionamiento =). Tambien podemos escribir en el...El puntero siempre estará al final tras escribir en el.
    fwrite ( t, sizeof ( Traductor ) * 5, 1, ptrFile );
    
    printf ( " Entre con una palabra en ingles a buscar en el\nregistro(La palabra debe existir en la estructura t, o no XD ).\n" );
    scanf ( "%29[^\n]%*c", buscado );
 
    long nRegistros;
    fseek ( ptrFile, 0, SEEK_END ); // Colocar el cursor al final del fichero
    nRegistros = ftell ( ptrFile ) / sizeof ( Traductor ); // Tamaño en registros
    printf ( "Hay %d registros en el fichero.\n", nRegistros );    
    
    int contador = 0;
    rewind ( ptrFile );    
    while ( fread ( &temp, sizeof ( Traductor ), 1, ptrFile ) ) {
        //Si la palabra existe en el fichero
        if ( strcmp ( temp.ingles, buscado ) == 0 ) {
            strcpy(temp.ingles, "CAMBIADO!INGLES"); //si encontramos la palabra ponemos eso en su lugar XD
            
            printf ( "\nLa palabra esta en el registro numero %d del fichero\n", contador+1 );
            
            fseek(ptrFile, sizeof ( Traductor )*contador, SEEK_SET);
            
            fwrite ( &temp, sizeof ( Traductor ), 1, ptrFile );            
            break;
        }
        
        contador ++;
        //Si la palabra NO existe en el fichero
        if ( contador == nRegistros ){
            printf("\nLa palabra no se encuentra en ninguno de los %d registros del fichero\n", nRegistros);
            break;
        }
    }
 
    fclose ( ptrFile );
    getchar();
    return  0;
}
 

Suerte XD

[rdv316]

Hola vangodp.
Para que no pienses que olvide del asunto te contesto ahora porque creo que voy a tardar unos 15 días de 8 horas para asimilar todo tú código.-
Lo voy a estudiar detenidamente, cualquier duda (20) te consulto, si lo quieres editar en las líneas 39 y 59 tendrías que poner %ld en reemplazo de %d, mi compilador marca advertencias.-

Saludos.
Daniel

[vangodp]

El programa crea un archivo(sobreescribiendo el anterior) con 5 registros para que posteriormente podemos buscar en el una palabra, esa es su función.

luego pido una palabra en ingles para buscar en el registro. Si abres el archivo verás que hay el contenido de t dentro del archivo.

obtengo el numero de bytes del registro con ftell ( ptrFile ) / sizeof ( Traductor ); y lo guardo en nRegistros. Viene explicado aquí: www.c.conclase.net/ficheros/?cap=004#inicio en la parte que pone "Calcular la longitud de un fichero".

La función ftell(fichero); me va decir cuantos Bytes hay en el fichero, cada registro tiene un tamaño de 61Bytes ya que has reservado 2 variables con 30 chars y una con un char que da en un total 61 Bytes por registro, todos tienen ese tamaño independientemente de si ocupas o no el tamaño completo ya que no se escribe en el pero si abres el archivo puedes apreciar que hay una separación entre las palabras muy grande.

Lo que hay en el archivo es lo que hay en t, 5 registros de 61 bytes cada o sea 5*sizeof(Traductor). ;)

Volviendo a ftell ( ptrFile )... Si ftell nos da el tamaño total en Bytes de 5 registros que sabemos que hemos puesto en el fichero el calculo seria ftell ( ptrFile ) / sizeof ( Traductor );, ese seria el numero de registros nRegistros. Podia poner directamente nRegistros = 5 ya que se que tiene un tamaño de 5. ¿Pero y en los casos que no se el tamaño? XD

Ahora que tenemos nRegistros entramos en el bucle de búsqueda. La magia esta en el contador puesto que a cada lectura con fread ( &temp, sizeof ( Traductor ), 1, ptrFile ) avanzamos un registro, si se encuentra lo que buscamos entramos en el primer if de ese bucle y lo frenamos para que no cuente más, yo le he cambiado la palabra en ingles por "CAMBIADO!INGLES" tu puedes tomar un valor por teclado para cambiar si quieres. XD

Ahora bien, ni siempre la palabra va existir en el fichero. ¿Si sabemos que nuestro fichero tiene 5 registros y no hemos encontrado a la palabra, es que la palabra no existe verdad? Para eso esta el segundo if, que averigua si el contador se puso a la par con nRegistros, lo que quiere decir que en el registro no le queda palabras por buscar y que a consecuencia no se encuentra tu palabra.

Si la palabra existe vas a verla cambiada por "CAMBIADO!INGLES" si no seguirá tal cual.

Ya no hay nada que explicar, el programa es muy sencillo, quitando los avisos que has dicho %ld todo ok XD

por si a la criatura esta no la conoces scanf ( "%29[^\n]%*c", buscado ); Te explico lo que hace. Lee 29 chars máximo hasta encontrar el enter, leyendo también espacios, tabuladores etc, evitando que entre enter en la cadena, y finalizando la con un '\0' al final. Si entras mas de 29 chars, el restante permanece en el buffer, entonces deberías limpiarlo.

Espero no haberte liado más jajaja

Suerte!

[ecfisa]

Hola rdv316.

Otro ejemplo con una función que te permite buscar una palabra en ambos idiomas:

Código C:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
 
#define SPA 'e'
#define ENG 'i'
 
typedef struct {
    char marcado;
    char ingles[30];
    char espaniol[30];
} Traductor;
 
// Busca palabras en archivo
long int searchWord( FILE* fp, char* word, char lang );
 
int main( ) {
  FILE *fp;
  Traductor tr;
  char lang, str[30];
  long int position;
 
  if( ( fp = fopen ( "traductor.dat", "rb+" ) ) == NULL ) {
    perror( "Error" );
    return EXIT_FAILURE;
  }
  // datos
  strcpy( str, "window" );  // palabra buscada
  lang = ENG; // idioma (tendrías que filtrar la entrada a: SPA o ENG)
  position = searchWord ( fp, str, lang );  // buscar
  // posicionarse en palabra buscada y mostrar
  if ( position != -1 ) {
    fseek ( fp, position - sizeof(tr)  , SEEK_SET );
    fread ( &tr, sizeof(tr), 1, fp);
    printf ( "%c %s %s\n\n", tr.marcado, tr.espaniol, tr.ingles );
  } else 
    printf ( "Palabra no encontrada" );
  fclose ( fp );
  return EXIT_SUCCESS;
}
 
/* Busca en el archivo una palabra en inglés o español ( preserva posición )
   Parámetros: puntero al archivo, palabra a buscar, idioma
   Devuelve: la posición en el archivo o -1 si no existe */
long int searchWord( FILE* fp, char* word, char lang ) {
  Traductor tr;
  long int mark, pos;
  lang = tolower(lang);
 
  // guardar posición actual
  mark = ftell ( fp );
  // posicionar al inicio
  rewind ( fp );
  // buscar
  if (lang == 'e' ) {
    while ( fread ( &tr, sizeof ( tr ), 1, fp ) && strcmp ( tr.espaniol, word ) );
    pos = ( strcmp ( tr.espaniol, word ) == 0 ) ? ftell ( fp ) : -1;
  } else {
    while ( fread ( &tr, sizeof ( tr ), 1, fp ) && strcmp ( tr.ingles, word ) );
    pos = ( strcmp ( tr.ingles, word ) == 0 ) ? ftell ( fp ) : -1;
  }
  // restaurar posición previa
  fseek ( fp, mark, SEEK_SET );
  // resultado
  return pos;
}
 

Saludos.

[rdv316]

Hola amigos.
Muchas gracias a los 2, ya conseguí lo que pretendía, luego voy a profundizar en los códigos de ambos para aprender cosas que seguramente desconozco.-
Una última ayudita, les pediría que recorran mi programita y me digan si está todo correcto o que debo corregir y que pasa si muevo el cursor más allá del último registro.-

Código:

#include <stdio.h>

typedef struct {
	char marcado;
	char ingles[30];
	char espaniol[30];
} Traductor;

int main(void){
	FILE *ptrFile;
	Traductor trad;
	long mark;
	
	if( ( ptrFile = fopen( "archivo.txt", "r" ) ) == NULL ){
		perror( "Error" );
		return 1;
	}

	// el modo r posiciona el cursor al comienzo del archivo.
	fseek (ptrFile, 1*sizeof(trad), SEEK_CUR); // mover el cursor 1 registro asía abajo.
	mark = ftell ( ptrFile ); // guardar posición actual 
	fread (&trad, sizeof ( Traductor ), 1, ptrFile ); 
	printf( "\n\n %s === %s\n\n", trad.ingles, trad.espaniol );

	fseek (ptrFile, 3*sizeof(trad), SEEK_CUR); // mover el cursor 3 registro asía abajo.
	fread (&trad, sizeof ( Traductor ), 1, ptrFile );
	printf( "\n\n %s === %s\n\n", trad.ingles, trad.espaniol );

	fseek ( ptrFile, mark, SEEK_SET );	// restaurar posición previa.
	fread (&trad, sizeof ( Traductor ), 1, ptrFile );
	printf( "\n\n %s === %s\n\n", trad.ingles, trad.espaniol );

 fclose(ptrFile);
	return 0;

}

Saludos y muchas gracias.
Daniel

[vangodp]

Tienes un error.
Para ficheros de texto no deberías utilizar SEEK_CUR en fseek, debería ser SEEK_SET. O sea que deberíamos leer siempre desde el comienzo el segundo parámetro es el que se debería encargar de mover el cursor(puntero). Con fseek (ptrFile, 3*sizeof(trad), SEEK_CUR); estas diciendo al programa que se desplace 3 registros más adelante pero desde la posición actual. no se si se puede hacer eso.

Al menos es lo que pone en la referencia de cplusplus: http://www.cplusplus.com/reference/cstdio/fseek/

...En la parte que dice:

For streams open in text mode, offset shall either be zero or a value returned by a previous call to ftell, and origin shall necessarily be SEEK_SET.

...Que traducido al google translator XD, nos dice:

Para flujos abiertos en modo texto, el offset(offset es el segundo parámetro de fseek ;) ) deberá o bien ser cero o otro valor devuelto por una llamada previa a ftell y origin( 3º parámetro ) deberá necesariamente ser SEEK_SET.

Ahora bien.. No se si esto es cierto o no debido que soy muy noobs XDD. A ver si alguien con más exp nos aclara eso.

Tampoco sabría decirte que pasa si leyemos más allá del fin, pero parece que no se produce la lectura.

Entonces la parte de mi código que te puse seria invalida ya que uso SEEK_END...¡PERO FUNCIONA!

Código C:

long nRegistros;
    fseek ( ptrFile, 0, SEEK_END ); // Colocar el cursor al final del fichero
    nRegistros = ftell ( ptrFile ) / sizeof ( Traductor ); // Tamaño en registros
    printf ( "Hay %d registros en el fichero.\n", nRegistros );
 

No se la verdad... Espero que nos aclaren por que ya tengo dudas hasta yo jajaj.

Suerte!

[lareto]

Llego tarde, pero quería alertar que no es correcto usar el sizeof de una struct para lectura o escritura en archivos, porque el tamaño (el size) de una struct depende del "data alignment" del compilador (o de cómo se haya seteado por línea de comando), y de la posición relativa de los miembros dentro de la struct. Pongo un ejemplo:

Código C++:

#include <iostream>
 
struct ejemplo1 {
    char a;
    int b;
    double c;
};
 
struct ejemplo2 {
    double c;
    char a;
    int b;
};
 
struct ejemplo3 {
    int b;
    double c;
    char a;
};
 
int main()
{
    std::cout << "sizof(char) + sizof(int) + sizeof(double) = "
              << sizeof(char) + sizeof(int) + sizeof(double) << '\n';
    std::cout << "sizeof(ejemplo1) = " << sizeof(ejemplo1) << '\n';
    std::cout << "sizeof(ejemplo2) = " << sizeof(ejemplo2) << '\n';
    std::cout << "sizeof(ejemplo3) = " << sizeof(ejemplo3) << '\n';
}
 

[vangodp]

ya... Llevas razón, pero en ese caso no afecta ya que todos los campos son chars.
En todo caso será mejor leer aquí para entender mejor y evitar futuros errores: http://c.conclase.net/curso/?cap=011b#STR_sizeof

A eso también se le dice alineación de bytes o byte-aling.

Lo mejor seria serializar todo en cadena de caracteres y enviar al archivo, luego pasar por el proceso inverso a la hora de leer.

[rdv316]

Hola.
Loreto, muchas gracias por tu participación, me podrías decir como seria la manera correcta sin sizeof.-

Iniciado por vangodp

....Lo mejor seria serializar todo en cadena de caracteres y enviar al archivo, luego pasar por el proceso inverso a la hora de leer.

Vangodp, hace más de 2 meses que me propusieron hacer eso de serializar y nadie me supo poner un ej. ni tampoco pude encontrar en internet nada al respecto ¿me podrías dar algún ej. alguna guia ?

Saludos.
Daniel

[lareto]

Para escribir y leer estructuras a y desde un archivo, yo haría dos funciones que escribieran y leyeran cada uno de los miembros. Por ejemplo:

Código C++:

void escribe_traductor(FILE *fp, Traductor *traductor)
{
    fwrite(&traductor->marcado, sizeof(char), 1, fp);
    fwrite(traductor->ingles, sizeof(char), 30, fp);
    fwrite(traductor->espaniol, sizeof(char), 30, fp);
}
 
void lee_traductor(FILE *fp, Traductor *traductor)
{
    fread(&traductor->marcado, sizeof(char), 1, fp);
    fread(traductor->ingles, sizeof(char), 30, fp);
    fread(traductor->espaniol, sizeof(char), 30, fp);
}
 

[vangodp]

Como te dijo lareto gran maestro, esta muy bien. =)

Yo haría algo así:

Código C:

#include <stdio.h>
#include <string.h>
 
typedef struct {
    char marcado;
    char ingles[30];
    char espaniol[30];
} Traductor;
 
int main (){
    FILE * f;
    
    f = fopen( "prueba.txt", "w+" );
    if (  f == NULL ){
        ferror(f);
        return 1;
    }
    
    //preparamos una estructura
    Traductor t[5] = {
        { '+', "door", "puerta"},
        { '+', "window", "ventana"},
        { '+', "rueda", "wheel"},
        { '+', "main", "principal"},
        { '+', "out", "salida"}
    };
    
    //grabamos en el fichero la estructura
    int i;
    for ( i = 0; i < 5; i++ ){
        fprintf( f, "%c %-30s %-30s\n",t[i].marcado, t[i].ingles,t[i].espaniol );
        
    }
    
    //volvemos a leer y sacamos lo leido por pantalla
    Traductor temp;
    rewind(f);
    for ( i = 0; i < 5; i++ ){
        fscanf( f, /*note el espacio antes de %c y lea el comentario->*/" %c %s %s",&temp.marcado, temp.ingles, temp.espaniol ); // el espacio inicial en la cadena de formato ignora leer el enter que grabamos anteriormente con fprintf para que cada estructura se guarde una abajo de otra y no todas seguidas XD
        printf("%c %s %s\n",temp.marcado, temp.ingles, temp.espaniol);
    }    
    
    
    fclose(f);
    getchar();
    return 0;
}
 

Así tienes hasta mas control en el formato de lo que va a salir en el fichero. Por ejemplo note que cada linea ahora es una estructura.

[rdv316]

Hola gente.
Tarde un tanto en responder porque estoy buscando lo que me faltaría para completar el tema y es cuando utilizar archivo de texto o archivo binario, la ventaja de uno sobre el otro, etc. Todavía no pude encontrar ninguna página que me aclare el tema, ni bien encuentre algo interesante lo posteo, para cerrar este post que realmente me aclaró muchos temas, muchas gracias a todos y espero encontrarlos siempre para disipar mis dudas que por cierto son muchas y Uds. Son muy claros para explicar.-
Si alguien desea hacer algún aporte Danielito muy agradecido.-

Saludos y un abrazo.
Daniel

[eferion]

Iniciado por rdv316

Hola gente.
Tarde un tanto en responder porque estoy buscando lo que me faltaría para completar el tema y es cuando utilizar archivo de texto o archivo binario, la ventaja de uno sobre el otro, etc. Todavía no pude encontrar ninguna página que me aclare el tema, ni bien encuentre algo interesante lo posteo, para cerrar este post que realmente me aclaró muchos temas, muchas gracias a todos y espero encontrarlos siempre para disipar mis dudas que por cierto son muchas y Uds. Son muy claros para explicar.-
Si alguien desea hacer algún aporte Danielito muy agradecido.-

Saludos y un abrazo.
Daniel

Un archivo de texto únicamente debería contener caracteres imprimibles... es decir, letras, números, espacios y demás signos. Además, se caracteriza porque el archivo está dividido en líneas de texto (usando el mismo juego de símbolos para delimitar cada línea: \n, \r\n o \n\r). Un archivo de texto lo puedes editar perfectamente con el block de notas. Normalmente su contenido puede ser leído por el usuario sin problemas.

En un archivo binario no hay reglas... admite cualquier caracter. La edición de un fichero binario hay que hacerlo con editores binarios para no alterar la información almacenada en el mismo.