ARCHIVOS DIRECTOS
TEMA 1: INTRODUCCION REGISTROS ESTRUCTURAS C++
SE DICE QUE UN ARCHIVO ES DE ACCESO U ORGANIZACION
DIRECTA CUANDO PARA ACCEDER A UN REGISTRO N
CUALESQUIERA NO SE TIENE QUE PASAR POR LOS N-1 REGISTROS
ANTERIORES.
Como se observa de esta definición los archivos directos tienen una gran ventaja(
son mucho mas rapidos) cuando se comparan con los archivos de acceso u
organizacion secuencial estudiados en la unidad anterior.
Es decir un archivo de acceso directo tiene que tener sus registros o renglones de
un tamaño fijo o predeterminado de antemano.
Un archivo de acceso directo permite posicionar el apuntador de interno de
registros, a cualquier registro determinado sin necesidad de pasar por todos los
registros anteriores, usando las siguientes funciones.
1) int fseek(apuntador,long offset,origen);
Esta función posiciona el apuntador de registro en el byte indicado. Regresa 0 si
se pudo posicionar.
apuntador = fopen(“c:\\[Link]”,”r+”);
fseek(apuntador,(long)(clave)*(sizeof(registro)),0);
0 —> SEEK_SET principio del archivo.
1 —> SEEK_CUR posicion actual.
2 —> SEEK_END fin del archivo.
2) long ftell(apuntador);
Regresa un valor long indicando la posicion actual del cursor interno de registros
de archivo.
3) int rewind(apuntador);
Regresa el apuntador al principio del archivo.
Ejemplo para hacer modificaciones.
fseek(apuntador,(long)(clave)*(sizeof(registro)),0);
fread(®istro,sizeof(registro),1,apuntador);
hacer las modificaciones.
rewind(apuntador);
fseek(apuntador,(long)(clave)*(sizeof(registro)),0);
fwrite(®istro,sizeof(registro),1,apuntador);
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
GRABACION DE UNA ESTRUCTURA A UN ARCHIVO EN DISCO
[Link]
#include <stdio.h>
#include <conio.h>
#include <string.h>
struct {
int clave;
char nombre[30];
int edad;
} animalito;
void main() {
clrscr();
// captura de campos
printf("dame clave :");scanf("%d",&[Link]);getchar();
printf("dame nombre :");gets([Link]);
printf("dame edad :");scanf("%d",&[Link]);
// grabando a disco
FILE *archdisco;
archdisco = fopen("c:\\ac\\[Link]","a+");
fwrite(&animalito,sizeof(animalito),1,archdisco);
fclose(archdisco);
//avisando usuario
printf("animalito insertado");
getchar();getchar();
}
CORRIDA:
Observar que es completamente similar aL programa de archivos secuenciales,
solo se recomienda y exije que las claves sigan la secuencia 0,1,2,3,4,5…..
Otra observación es que se esta usando el “fopen()” en modo “ab+” en lugar de
modo “w” pero es para matar dos pajaros de un tiro, reestudiar la clase de modos
de apertura.
La instrución de grabación es:
fwrite(&animalito,sizeof(animalito),1,archdisco);
que ya se estudio anteriormente.
LECTURA CONSULTA DESPLIEGUE DE REGISTROS
[Link]
#include <stdio.h>
#include <conio.h>
#include <string.h>
struct {
int clave;
char nombre[30];
int edad;} animalito;
void main() {
clrscr();
// leyendo disco
FILE *archdisco;
archdisco = fopen("cpp:\\ac\\[Link]","rb+");
// aqui siempre debe empezar el ciclo de lectura
// y fread() regresa siempre cuantas estructuras leyo
while(fread(&animalito,sizeof(animalito),1,archdisco)==1)
{
// desplegando estructuras
printf("%d ",[Link]);
printf("%s ",[Link]);
printf("%d ",[Link]);
printf("\n");
}; // aqui termina while
// no olvidar cerrar archivo y siempre fuera de while
fclose(archdisco);
getchar();getchar();
}
CORRIDA:
Seria bueno que el despliegue fuese en una tabla pero esto queda de tarea.
TAREAS PROGRAMAS EN C++
1.- Cargar y Leer los archivos pedidos en el tema anterior.
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
UNIDAD 6: C++ REGISTROS Y ARCHIVOS DIRECTOS
TEMA 4: BUSQUEDA ARCHIVOS C++
En este tema se analiza la busqueda de un registro o renglón determinado.
En este proceso el usuario del programa quiere que se despliegue un y solo un
registro de información proporcionando un dato de busqueda generalmente la
clave del registro.
Recordar que en esta operación se muestra la diferencia fundamental entre
archivos secuenciales y archivos directos, es decir aqui se puede accesar
directamente un registro n cualesquiera.
[Link]
#include <stdio.h>
#include <conio.h>
#include <string.h>
struct {
int clave;
char nombre[30];
int edad;} animalito;
void main() {
clrscr();
// cargando clave a buscar
printf("dame clave buscar:");
int claveb; scanf("%d",&claveb);
//abriendo, leyendo,cargando estructura
FILE *archdisco;
archdisco = fopen("cpp:\\ac\\[Link]","ab+");
// usar fseek() para posicionarse al principio de registro buscado
fseek (archdisco, (long)(claveb)* sizeof(animalito), 0 );
// ahora se lee el registro
fread(&animalito,sizeof(animalito),1,archdisco);
// desplegando estructura y asegurandose
printf("%d ",[Link]);
printf("%s ",[Link]);
printf("%d ",[Link]);
printf("\n");
// no olvidar cerrar archivo
fclose(archdisco);
getchar();getchar();
}
corrida:
Como se desprende del programa usando fseek() es posible posicionarse en
cualquier byte del archivo.
El formato completo de fseek() es:
fseek(apuntador,(long)(clave)*(sizeof(registro)),0);
donde los parametros son:
1. Apuntador al archivo en disco
2. El segundo parametro es el BYTE donde se quiere que empieze la lectura o
grabación al archivo en disco.
3. Este BYTE debe ser de tipo LONG asi que si en algun programa de ejemplo
ven fseek( , 387L, ); que no les llame la atención, es otra manera de hacerle cast a
un dato.
Como va a estar dificil que se le atine a un byte determinado, es por eso que en el
programa mejor se deja que sea el propio servidor quien calcule el byte donde
empieza un registro determinado con clave * sizeof o tamaño de registro.
4. El tercer parametro es a partir de donde se quiere posicionar el apuntador
interno del archivo, los valores pueden ser:
0 → SEEK_SET principio del archivo.
1 → SEEK_CUR posicion actual.
2 → SEEK_END fin del archivo.
RECORDAR QUE ES MUY IMPORTANTE QUE LAS CLAVES
GRABADAS EN UN ARCHIVO DIRECTO TENGAN LA SECUENCIA
0,1,2,3,4,5…..N
TAREAS PROGRAMACION C++
Construirles programas de busquedas a los archivos ya construidos.
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
UNIDAD 6: C++ REGISTROS Y ARCHIVOS DIRECTOS
TEMA 4: BUSQUEDA ARCHIVOS C++
En este tema se analiza la busqueda de un registro o renglón determinado.
En este proceso el usuario del programa quiere que se despliegue un y solo un
registro de información proporcionando un dato de busqueda generalmente la
clave del registro.
Recordar que en esta operación se muestra la diferencia fundamental entre
archivos secuenciales y archivos directos, es decir aqui se puede accesar
directamente un registro n cualesquiera.
[Link]
#include <stdio.h>
#include <conio.h>
#include <string.h>
struct {
int clave;
char nombre[30];
int edad;} animalito;
void main() {
clrscr();
// cargando clave a buscar
printf("dame clave buscar:");
int claveb; scanf("%d",&claveb);
//abriendo, leyendo,cargando estructura
FILE *archdisco;
archdisco = fopen("cpp:\\ac\\[Link]","ab+");
// usar fseek() para posicionarse al principio de registro buscado
fseek (archdisco, (long)(claveb)* sizeof(animalito), 0 );
// ahora se lee el registro
fread(&animalito,sizeof(animalito),1,archdisco);
// desplegando estructura y asegurandose
printf("%d ",[Link]);
printf("%s ",[Link]);
printf("%d ",[Link]);
printf("\n");
// no olvidar cerrar archivo
fclose(archdisco);
getchar();getchar();
}
corrida:
Como se desprende del programa usando fseek() es posible posicionarse en
cualquier byte del archivo.
El formato completo de fseek() es:
fseek(apuntador,(long)(clave)*(sizeof(registro)),0);
donde los parametros son:
1. Apuntador al archivo en disco
2. El segundo parametro es el BYTE donde se quiere que empieze la lectura o
grabación al archivo en disco.
3. Este BYTE debe ser de tipo LONG asi que si en algun programa de ejemplo
ven fseek( , 387L, ); que no les llame la atención, es otra manera de hacerle cast a
un dato.
Como va a estar dificil que se le atine a un byte determinado, es por eso que en el
programa mejor se deja que sea el propio servidor quien calcule el byte donde
empieza un registro determinado con clave * sizeof o tamaño de registro.
4. El tercer parametro es a partir de donde se quiere posicionar el apuntador
interno del archivo, los valores pueden ser:
0 → SEEK_SET principio del archivo.
1 → SEEK_CUR posicion actual.
2 → SEEK_END fin del archivo.
RECORDAR QUE ES MUY IMPORTANTE QUE LAS CLAVES
GRABADAS EN UN ARCHIVO DIRECTO TENGAN LA SECUENCIA
0,1,2,3,4,5…..N
TAREAS PROGRAMACION C++
Construirles programas de busquedas a los archivos ya construidos.
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
UNIDAD 6: C++ REGISTROS Y ARCHIVOS DIRECTOS
TEMA 5: FILTROS CONDICIONES C++
Otro problema similar al anterior es el de filtros o condiciones, es decir en
muchas ocasiones es necesario obtener información acerca de un subconjunto de
renglones de el archivo.
Por ejemplo todos los estudiantes que sean mayores de 17 años, o todos los
clientes que sean de Tijuana, etc. a esto le llamamos filtros o condiciones.
Tambien se resuelve de manera similar a los de archivos secuenciales es decir
usando un ciclo de lectura de todo el archivo e ir desplegando todos los registros
que cumplan la condicion.
[Link]
#include <stdio.h>
#include <conio.h>
#include <string.h>
struct {
int clave;
char nombre[30];
int edad;} animalito;
void main() {
clrscr();
// cargando clave a buscar
printf("EDAD MAYOR QUE >= :");
int edad; scanf("%d",&edad);getchar();
//abriendo, leyendo,cargando estructura
FILE *archdisco;
archdisco = fopen("cpp:\\ac\\[Link]","at+");
// aqui siempre debe empezar el ciclo de lectura
// y fread() regresa siempre cuantas estructuras leyo
while(fread(&animalito,sizeof(animalito),1,archdisco)==1)
{
// desplegando estructura buscada
if ([Link] >= edad)
{ printf("%d ",[Link]);
printf(" %s ",[Link]);
printf(" %d ",[Link]);
printf("\n");};
}; // aqui termina while
// no olvidar cerrar archivo y siempre fuera de while
fclose(archdisco);
getchar();
}
corrida:
Como se observa es un problema y una solución similar al tema anterior de
busquedas.
TAREAS PROGRAMACION C++
HACERLES PROGRAMAS DE FILTRADO A LOS ARCHIVOS DE C++
ANTERIORES
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
UNIDAD 6: C++ REGISTROS Y ARCHIVOS DIRECTOS
TEMA 6: BAJAS O ELIMINACIONES C++
Eliminación o bajas es el proceso por medio del cual algunos registros del
archivo son purgados del archivo, existen dos maneras por las cuales se puede
realizar ese proceso.
En la primera manera se usan dos archivos, el archivo original y un archivo
temporal, el procedimiento o algoritmo es muy sencillo, se lee el registro del
archivo original y si no es el registro a eliminar entonces se almacena en el
archivo temporal, cuando se termina de procesar todo el archivo original, el
archivo temporal solo contendra todos los registros que no se quisieron eliminar,
ya con estos dos archivo se procede a eliminar o borrar usando la instruccion
remove el archivo original y se procede a renombrar usando la instrucción
rename de el archivo temporal como nuevo archivo original.
Sin embargo en archivos directos no se puede ni se debe eliminar fisicamente
registros de los archivos porque recordar que la clave del registro esta enlazada
directamente a la posición que dicho registro tiene en disco y no seria muy
conveniente estarle cambiando la matricula al alumno cada rato o el numero de
serie al auto, etc.
Aparte de que con esta manera de eliminar incluso fisicamente los registros del
archivo es que no hay manera de recuperar esa información posteriormente.
Es por eso que otra tecnica común de eliminación es incluir un campo de estado,
status o bandera o semaforo en el registro y conforme se va cargando el registro y
antes de mandarlo a disco se le agrega a dicho campo el caracter 'A' → alta, asi
que cuando se quiera una baja solo se pondria dicho campo en 'B' y todos los
programas de lectura, busqueda y filtros deberan revisar esta campo de estado
antes de hacer algo con el registro.
TAREAS PROGRAMACION C++
Construir programas de eliminacion usando el segundo metodo( bajas logicas
como se indica en el ultimo parrafo) para los archivos construidos y no olvidar
reconstruir los programas anteriores para que incluyan y tomen en cuenta el
nuevo campo.
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
UNIDAD 6:C++ REGISTROS Y ARCHIVOS DIRECTOS
TEMA 7: OPERACIONES CON CAMPOS C++
En este tema se analiza la manera de poder realizar operaciones o procesos con
los campos de los registros en el archivo DIRECTO, lo unico importante a
considerar es que los campos del registro son en cierta medida igual que
variables normales y por tanto se pueden procesar de manera normal como lo
muestra el ejemplo.
[Link]
#include <stdio.h>
#include <io.h>
#include <conio.h>
#include <string.h>
struct {
int clave;
char nombre[30];
int edad;} animalito;
void main() {
clrscr();
FILE *arch1;
long r=0;
arch1 = fopen("cpp:\\ac\\[Link]","rb+");
while (fread(&animalito,sizeof(animalito),1,arch1)==1)
{
// sumando 100 a edad
[Link] = [Link] + 100 ;
// como ya se leyo se regresa el apuntador al principio del registro
fseek(arch1,r*sizeof(animalito),0 );
// y se escribe el registro modificado al archivo
fwrite(&animalito,sizeof(animalito),1,arch1);
r=r+1;
//turboc no permite i/o archivos sin un rewind, fseek, etc
fseek(arch1,r*sizeof(animalito),0);
}; // aqui termina for
//cerrando archivo
fclose(arch1);
//avisando
puts("EDADES + 100");
getchar();getchar();
}
corrida prog27:
corrida prog30
corrida prog27
como se observa la solución es muy sencilla solo se ocupa:
1.- leer fread() el registro, esto mueve el apuntador al siguiente registro.
2.- modificar registro
3.- regresar a posición anterior con fseek()
4.- grabar fwrite() el registro corregido
5.- volver a usar un fseek() porque turboc no acepta i/o sin rewind, fseek, etc ver
ayuda del compilador
y no se ocupan los dos archivos como en el caso secuencial.
TAREAS PROGRAMACION C++
CONSTRUIRLES PROGRAMAS QUE PROCESEN ALGUNOS CAMPOS DE
LOS ARCHIVOS C++ EJEMPLOS QUE YA TIENEN CONSTRUIDOS.
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
UNIDAD 6: C++ REGISTROS Y ARCHIVOS DIRECTOS
TEMA 8: EDICION MODIFICACION DE REGISTROS C++
Modificar o editar un registro es uno de los procesos mas comunes con archivos
en disco, generalmente despues de un fuerte proceso de captura de registros, una
revisión o consulta general muestra muchos de ellos con errores de captura.
vamos a editar el segundo registro.
[Link]
#include <stdio.h>
#include <conio.h>
#include <string.h>
struct {
int clave;
char nombre[30];
int edad;} animalito;
void main() {
clrscr();
// cargando clave a buscar
printf("dame clave editar:");
int claveb; scanf("%d",&claveb);
//abriendo, leyendo,cargando estructura
FILE *archdisco;
archdisco = fopen("cpp:\\ac\\[Link]","rb+");
// usar fseek() para posicionarse al principio de registro buscado
fseek (archdisco, (long)(claveb)* sizeof(animalito), 0 );
// ahora se lee el registro
fread(&animalito,sizeof(animalito),1,archdisco);
// desplegando estructura y asegurandose
printf("%d ",[Link]);
printf("%s ",[Link]);
printf("%d ",[Link]);
printf("\n");getchar();
//recapturando los nuevos datos
printf("dame nuevo nombre :");gets([Link]);
printf("dame nueva edad :");scanf("%d",&[Link]);
// regresando a apuntador para regrabar
fseek (archdisco, (long)(claveb)* sizeof(animalito), 0 );
fwrite(&animalito,sizeof(animalito),1,archdisco);
// no olvidar cerrar archivo
fclose(archdisco);
//avisando
printf("REGISTRO EDITADO");
getchar();getchar();
}
corrida:
Observar que es el programa normal de busqueda pero ya desplegado el registro
se piden los nuevos datos, posteriormente se regresa el apuntador de registros a la
posición original para volverse a regrabar el registro pero con los datos ya
editados.
TAREAS PROGRAMACION C++
CONSTRUIRLES PROGRAMAS DE EDICION O MODIFICACION A LOS
ARCHIVOS YA CONSTRUIDOS.
