Ar Chivos

SIS 1101 METODOLOGIA DE LA PROGRAMACIN II ARCHIVOS
_______________________________________________________________________________________
Capitulo 5.
ARCHIVOS DE DATOS

5.1 INTRODUCCIN
Los archivos de datos permiten almacenar informacin de modo permanente, para ser
accedida o alterada cuando sea necesario.
Hasta ahora un programa poda almacenar informacin en la memoria mediante las
variables declaradas (tipos elementales, estructuras, tablas). Este almacenamiento es
temporal y est limitado al tiempo de ejecucin del programa.
Cuando surge la necesidad de almacenar informacin de manera permanente se deben usar
ficheros. Un fichero es una entidad que contiene informacin de un conjunto de elementos.
El fichero puede estar guardado en algn medio de almacenamiento secundario como por
ejemplo disco rgido, disckette, etc. La agrupacin de ficheros relacionados entre s por
algn concepto se denomina base de datos.

5.2. CARACTERSTICAS DE UN ARCHIVO O FICHERO.
Las principales caractersticas son:
Un fichero se identifica por su nombre, el cual generalmente est compuesto por:
o Path: indica la ruta para encontrar el fichero incluyendo la unidad de
almacenamiento donde se halla.
o Nombre
o Extensin: son tres caracteres que sirven para identificar el tipo de fichero
Ejemplo: "C:\Mis documentos\apuntes.doc"
______________________________________________________________________
Autor: M.Cs. Ing. J ulio Cesar Bermdez Vargas 80
_______________________________________________________________________________________
Un fichero puede estar compuesto por registros, cada uno de los cuales contiene
informacin sobre un elemento. Un registro est compuesto por campos. Se denomina
clave de acceso o identificador de registro al conjunto de campos mnimo que permite
identificar de manera nica cada registro.
Ejemplo: se tiene un fichero de registros o estructuras Articulo

struct Articulo
{
int codigo;
char descripcion[25];
float precio;
};
La clave de acceso de cada registro es el campo cdigo, pues dado un cdigo en
particular se puede identificar un nico registro. En cambio, el campo precio no
sirve como clave de acceso pues puede existir ms de un artculo con el mismo
precio.

El modo de acceso a los datos de un fichero puede ser de dos tipos:
o Secuencial: para acceder al elemento i-simo se recorre desde el primer
elemento hasta el elemento i-1.
Ejemplo: el almacenamiento en una cinta es de acceso secuencial.
o Directo: para acceder al elemento i-simo se hace directamente.
Ejemplo: el almacenamiento en un disco es de acceso directo.
El modo de organizacin lgica de los datos de un fichero puede ser de tres maneras:
______________________________________________________________________
_______________________________________________________________________________________
o Secuencial: las consultas de los registros se hace secuencialmente desde el
primer elemento hasta el elemento i-simo. La alta de un nuevo registro se
realiza al final del fichero.
o Directa: se establece una relacin entre la clave del registro y la posicin del
registro en el fichero. Para acceder al elemento i-simo se aplica una funcin
de acceso que calcula la posicin del registro en el fichero de acuerdo a la
clave del mismo.

Ejemplo: se tiene un fichero de registros Articulo cuyo campo clave es el
cdigo. Los cdigos son nmeros que van de 10 en 10, ej. 10, 20, 30, 40, 50,
etc. Se realiza la siguiente funcin de acceso F:

F (cdigo) =cdigo / 10;

la cual que devuelve la posicin del registro a partir del cdigo, y por lo
tanto puede accederse a l directamente.

o Indexada: bsicamente es una organizacin secuencial a la que se le agrega
una o ms tablas de ndices que permiten acceder a los registros de manera
ms directa.
Ejemplo: se tiene un fichero de registros Articulo cuyo campo clave es el
cdigo. Los cdigos son nmeros que no siguen un orden determinado, por
lo tanto no se puede construir una funcin de acceso directo. Se construye
una tabla de ndices que permite acceder directamente a los registros cuyo
cdigo se encuentra en un rango dado. Si se desea buscar los registros
mediante parte de su descripcin, se puede construir otra tabla de ndices
que permita, por ejemplo, acceder a todos los registros cuya descripcin
comienza con una letra o una serie de letras dadas.

______________________________________________________________________
_______________________________________________________________________________________
5.3. JERARQUIA DE DATOS.

23J UAN LUIS 1217.5
34ANA MARIA 1418.3
archivo 2PEDRO 671.89
56CARLA 218.97

registro 34ANA MARIA 1418.3

Campo ANA MARIA

Byte 1001010

Bit 1

5.4 APERTURA Y CIERRE DE UN ARCHIVO
Cuando se trabaja con archivos secuenciales de datos, el primer paso es establecer un rea de
buffer, donde la informacin se almacena temporalmente mientras se est transfiriendo entre
la memoria y el archivo de datos. Este rea de buffer permite leer y escribir informacin del
archivo ms rpidamente de lo que sera posible de otra manera. El rea de buffer se
establece escribiendo

FILE *ptvar;
donde FILE es un tipo de estructura que establece el rea de buffer y ptvar la variable puntero
que indica el comienzo de este rea. El tipo de estructura FILE est definido en stdio.h.
______________________________________________________________________
_______________________________________________________________________________________
Un archivo de datos debe ser abierto antes de ser creado o procesado. Esto asocia el nombre
del archivo con el rea de buffer. Tambin se especifica cmo se va a usar el archivo.
Para abrir un archivo se usa la funcin fopen:
ptvar = fopen ( nombre_archivo, tipo_archivo);
donde nombre_archivo y tipo_archivo son cadenas. Los tipos de archivo y su significado
son:
"r": Abrir un archivo existente slo para lectura.
"w": Abrir un nuevo archivo slo para escritura. Si ya existe, ser destruido y creado uno
nuevo en su lugar.
"a": Abrir un archivo para aadir. Si no existe, se crea uno nuevo.
"r+": Abrir un archivo existente para lectura y escritura.
"w+": Abrir un archivo nuevo para lectura y escritura. Si ya existe, ser destruido y creado
uno nuevo en su lugar.
"a+": Abrir un archivo existente para leer y aadir. Si no existe, se crea uno nuevo.
La funcin fopen retorna un puntero al principio del rea de buffer asociada con el archivo.
Se retorna un valor NULL si no se puede abrir el archivo.
Un archivo de datos debe cerrarse al final del programa
fclose(ptvar);

5.5. CREACIN DE UN ARCHIVO
Un archivo secuencial de datos puede crearse de dos formas distintas. Una es crear el archivo
directamente, usando un editor. La otra es escribir un programa que introduzca informacin
______________________________________________________________________
_______________________________________________________________________________________
en la computadora y la escriba en un archivo. Los archivos sin formato slo pueden crearse
mediante programa.
Cuando se crea un archivo con un programa, lo habitual es introducir la informacin desde el
teclado y escribirla en el archivo.
Si el archivo consta de caracteres individuales, se pueden usar la funciones getchar (para
obtener caracteres de teclado) y putc (para escribir caracteres en un archivo). El uso de putc
es el siguiente:
putc(variable_de_tipo_caracter,puntero_al_area_de_buffer);
Un archivo creado de esta manera puede ser visualizado de distintas formas:
Usando una orden del sistema operativo tal como type, usando un editor o escribiendo un
programa que lea el contenido y lo muestre. Para ello se pueden utilizar las funciones getc
(para leer caracteres de un archivo) y putchar (para escribir caracteres por pantalla). El uso de
getc es:
variable_de_tipo_caracter=getc (puntero_al_area_de_buffer);
Los archivos de datos que contienen slo cadenas de caracteres pueden crearse y leerse ms
fcilmente con programas que utilizan funciones de biblioteca especialmente orientadas para
cadenas: fgets y fputs.
Muchos archivos de datos contienen estructuras de datos ms complicadas, como struct que
incluyen combinaciones de informacin, caracteres y nmeros. Tales archivos se pueden
procesar usando las funciones fscanf y fprintf:
fprintf(puntero_area_buffer,cadena_control,argto1,..,argton);
fscanf(puntero_area_buffer,cadena_control,&argto1,..,&argton);
Una vez creado un archivo de datos surge la pregunta de cmo detectar una condicin de fin
de archivo. La funcin feof sirve para este propsito (vlida para un archivo secuencial con o
______________________________________________________________________
_______________________________________________________________________________________
sin formato). Esta funcin devuelve un valor distinto de cero (cierto) si detecta una
condicin de fin de archivo y un valor cero (falso) si no se detecta.

5.6. PROCESAMIENTO DE UN ARCHIVO
Para actualizar los registros dentro de un archivo de datos hay varios enfoques. Uno de ellos
consiste en leer cada registro del archivo, actualizarlo y escribirlo en el mismo archivo. Sin
embargo es difcil leer y escribir datos con formato al mismo archivo sin alterar la ordenacin
de los elementos dentro del archivo.
Otro enfoque es trabajar con dos archivos diferentes: un archivo antiguo (la fuente) y otro
nuevo. Se lee cada registro del archivo antiguo, se actualiza y se escribe en el archivo nuevo.

5.7 ARCHIVOS SIN FORMATO
Algunas aplicaciones implican el uso de archivos para almacenar bloques de datos, donde
cada bloque consiste en un nmero fijo de bytes contiguos. Cada bloque representar
generalmente una estructura de datos compleja, como una struct o un array. Para estas
aplicaciones sera deseable leer o escribir el bloque entero del archivo de datos en vez de leer
o escribir separadamente las componentes individuales de cada bloque.
Las funciones fread y fwrite deben usarse en estas situaciones. A estas funciones se las
conoce como funciones de lectura y escritura sin formato. Igualmente se hace referencia a
estos archivos de datos como archivos de datos sin formato.
Cada una de estas funciones necesita cuatro argumentos:
- la direccin del bloque de datos
- el tamao del bloque de datos
- el nmero de bloques a transferir
- el puntero a un archivo secuencial
______________________________________________________________________
_______________________________________________________________________________________

Ejemplo:
fwrite(&cliente, sizeof(registro), 1, ptvar);
fread(&cliente, sizeof(registro), 1, ptvar);
donde cliente es una variable estructura de tipo registro y ptvar un puntero a archivo
secuencial.

5.8. OPERACIONES CON FICHEROS
Existen operaciones que afectan a todo el fichero, entre las cuales se enumeran:
Crear un fichero
Borrar un fichero
Ordenar un fichero segn algn criterio de orden
Fusionar dos ficheros para formar un tercer fichero
Dividir un fichero en dos o ms ficheros
Adems, existen otras operaciones que afectan a uno o ms registros del fichero, entre las
cuales se enumeran:
Alta de un nuevo registro
Baja de un registro
Modificacin de uno o ms registros
Consulta de uno o m registros

5.8.1. STREAMS
Existe una manera de manipular ficheros en C++mediante los denominados streams.
______________________________________________________________________
_______________________________________________________________________________________
Un stream representa un flujo de informacin:
desde el programa a un dispositivo o perifrico de salida, o
desde un perifrico de entrada al programa
La manera de utilizar un stream de entrada es:
stream_entrada >>variable;
La manera de utilizar un stream de salida es:
stream_salida << informacin;
Hasta el momento se han utilizado dos streams predefinidos:
o cin es un stream de entrada asociado al teclado
o cout es un stream de salida asociado a la pantalla
Pueden definirse stream de entrada y/o salida y asociarlos a un fichero, de manera que se
puedan recibir datos del fichero y/o enviar datos al fichero respectivamente.

La librera que se debe utilizar es <fstream.h>.
Se debe declarar un stream mediante el constructor:
fstream nombre_stream (nombre_fichero, opciones);

Los parmetros son optativos. Si estn presentes sirven para realizar la apertura del fichero.
El nombre del fichero es un string que indica la ruta del fichero que se asocia al stream.
Las opciones indican diferentes modos entre los cuales se encuentran:
ios::in: crea un stream de entrada, es decir, para lectura de datos del fichero
ios::out: crea un stream de salida, es decir, para escritura de datos en el fichero
ios::ate: hace que la posicin inicial sea al final del fichero
ios::app: se sita al final del fichero antes de cada escritura
ios::trunc: borra cualquier cosa que pudiera haber en el fichero
ios::nocreate: si el fichero no existe fallar
ios::noreplace: si el fichero existe fallar
ios::bin: abre el fichero como binario

______________________________________________________________________
_______________________________________________________________________________________
Estas opciones pueden combinarse mediante el operador | .

Ejemplo:
/* stream de salida asociado al fichero prueba.txt. Se borra cualquier contenido del mismo
*/
fstream fichero1 ("prueba.txt", ios::out|ios::trunc);
/* Slo es vlido realizar escrituras dado que el stream es de salida*/
int i :=... ; // por ej. para escribir el valor de un entero
fichero1 << i;

Ejemplo:
/* stream de entrada asociado al fichero prueba.txt */
fstream fichero2 ("prueba.txt", ios::in);
/* Slo es vlido realizar lecturas dado que el stream es de entrada*/
int i; // por ej. para leer el valor de un entero
fichero2 >> i;

Existen diferentes operaciones que pueden realizarse con un fstream usando la siguiente
sintaxis:
nombre_fstream.operacion

Entre las operaciones disponibles se encuentran:
open(nombre_fichero, opciones), con los mismos parmetros que el constructor.
Puede usarse cuando en el constructor se ignor la apertura del fichero.
Ejemplo:
fichero1.open("prueba.txt", ios::in); // antes de realizar cualquier lectura
close(), cuando se desea cerrar un stream
Ejemplo:
fichero1.close(); // despues de haber realizado todas las lecturas y/o escrituras
______________________________________________________________________
_______________________________________________________________________________________
eof(), es una funcin que devuelve un valor diferente a 0 (TRUE) si se lleg al fin
de fichero, de otro modo devuelve 0 (FALSE)
Ejemplo:
if (fichero1.eof()){
//fin de fichero, no hay ms datos
}

is_open() es una funcin que devuelve un valor diferente a 0 (TRUE) si el fichero
asociado al stream est abierto, de otro modo devuelve 0 (FALSE).
Ejemplo:
if (fichero1.is_open()){
//el fichero est abierto
}
Se debe considerar que para leer o escribir un stream existe un "cabezal" que se
posiciona en el lugar a realizar la operacin. Las siguientes funciones informan la
posicin o manipulan el cabezal.
tellp(), es una funcin que devuelve como resultado la posicin actual (tipo
pos_type) de un stream de salida
seekp(posicin, posicin_inicial), sita el lugar de escritura indicada en posicin en
forma relativa a posicion_inicial, la cual puede ser ios::beg (comienzo), ios::cur
(actual), ios::end (fin).

5.9. FICHEROS DE ESTRUCTURAS

Cuando se quiere guardar informacin de estructuras o registros en C/C++se deben utilizar
las funciones de ficheros de la librera <stdio.h>.

Existe un tipo de datos denominado FILE por medio del cual se manipulan los ficheros.
Entre las funciones definidas para trabajar con ficheros se encuentran:
FILE * fopen (const char *name, const char *mode)
______________________________________________________________________
_______________________________________________________________________________________

La funcin fopen recibe como parmetros:
o un string name con el nombre del fichero
o un string mode con el modo de apertura del fichero que puede ser:
"r" : abre fichero existente para lectura. Si no existe falla la operacin
"w" : abre fichero para escritura. Si existe, sus contenidos se borran.
"a" : abre fichero para escritura. Si existe, se agregan los datos al final
"r+" : abre fichero para lectura y escritura. El fichero debe existir.
"w+" : abre fichero para lectura y escritura. Si existe, sus contenidos se
borran
"a+" : abre fichero para lectura y escritura. Si existe, se agregan datos al
final
Devuelve un puntero a un fichero, que en caso de error en la operacin ser NULL.
int fclose (FILE *file)
La funcin fclose cierra el fichero abierto file.
Devuelve un int que si es 0 indica que la operacin se realiz con xito.
size_t fread (void *pbuffer, size_t size, size_t number, FILE *file)

La funcin fread se usa para leer desde el fichero, y recibe como parmetros:
o un puntero a FILE del fichero file desde el cual se quiere leer
o un nmero number de tipo size_t que indica la cantidad de elementos que se
quiere leer
o un nmero size de tipo size_t que indica el tamao en bytes de cada
elemento
o un puntero pbuffer a un lugar donde se copiarn los elementos ledos.
______________________________________________________________________
_______________________________________________________________________________________
Considerar que el tamao que debe tener el buffer apuntado por pbuffer tiene que se
lo suficientemente grande como para albergar la cantidad de elementos indicada.
Devuelve un nmero de tipo size_t que indica el nmero de elementos que se han ledo.
size_t fwrite (void *pbuffer, size_t size, size_t number, FILE *file)
La funcin fwrite se usa para escribir en el fichero, y recibe los mismos parmetros
que la funcin fread.

Devuelve un nmero de tipo size_t que indica el nmero de elementos que se han
escrito.
int fseek (FILE *file, long offset, int mode)
La funcin fseek desplaza el cabezal de lectura, y recibe los parmetros:
o un long offset que indica la cantidad de bytes que se desplaza
o un int mode que indica desde dnde se desplaza, con uno de los siguientes
valores:

SEEK_SET: desde el comienzo
SEEK_CUR: desde el cursor
SEEK_END: desde el final
Devuelve un int que si es 0 indica que la operacin se realiz con xito.
int ftell (FILE *file)
La funcin ftell devuelve un int que indica el nmero de bytes desde el comienzo hasta
la posicin donde se encuentra el cabezal de lectura.
______________________________________________________________________
_______________________________________________________________________________________

int feof (FILE *file)

Luego del primer intento de lectura ms all de la seal de fin de fichero, la funcin
feof devuelve un valor diferente de 0.
Devuelve 0 mientras las lecturas hehcas no lleguen al final del fichero.
void rewind (FILE *file)

La funcin rewind sita el cabezal de lectura al inicio del fichero.
Cabe destacar que tanto las funciones fread, fwrite, fseek, ftell manejan posiciones o tamaos
indicados en bytes. Para obtener el tamao en bytes de una estructura dada puede usarse la
funcin sizeof (estructura) y con este valor pueden calcularse los parmetros necesarios de las
funciones anteriores.

Ejemplo: Crear un fichero de artculos. Se debe permitir agregar artculos, modificar un
artculo existente y listar todos los artculos existentes.

#include <iostream.h>
#include <stdio.h>
const int maxart =100;

const int maxdesc =30;
struct articulo {
int codigo;

char descripcion[maxdesc];

float precio;
};
// La funcin mostrararticulo muestra por pantalla un artculo dado
// por simplicidad de la funcin no se la desglosar
______________________________________________________________________
_______________________________________________________________________________________

void mostrararticulo (struct articulo art);
// La funcin leerarticulo permite introducir por teclado los datos de un artculo
// no se la implementa.

struct articulo leerarticulo ();
struct articulo leerarticulo (int codigo){

//Asigna el codigo al articulo y permite al usuario introducir el resto de los campos
struct articulo art;
art.codigo =codigo;
leerdescripcion(art.descripcion);
leerprecio(art.precio);
return art;
}
void copiararticulo(struct articulo art_origen, struct articulo *part_destino){
// Esta funcion copia los datos del articulo art_origen en el articulo apuntado por el puntero
//part_destino

// Notar: dado que ha sido pasado el puntero no se debe pasar por referencia el parmetro.
//Si en cambio, se hubiera pasado una estructura debera haber sido por referencia, es decir,
//struct articulo &art_destino
part_destino ->codigo =art_origen.codigo;
part_destino ->precio =art_origen.precio;
for (int i=0;i<maxdesc;i++){
part_destino->descripcion[i] =art_origen.descripcion[i];
}
}
void ListarElementos(char *nombre) {
FILE *f;
// El fichero se abre slo para lectura y se espera que exista
f =fopen (nombre, "r");
if (f !=NULL){
fread (&art, sizeof(struct articulo), 1, f);
while (!feof(f)){ // la condicin equivale a (feof(f) !=0)
mostrararticulo(art);
fread (&art, sizeof(struct articulo), 1, f);
}
fclose (f);
}
else cout <<"Error de apertura del fichero";
}
int BuscarArticulo (char *nombre, struct articulo *art){

// Esta funcin busca en el fichero la existencia de un registro con codigo igual al del
//articulo apuntado por art
______________________________________________________________________
_______________________________________________________________________________________

// Si lo encuentra devuelve la posicin en bytes del registro y copia el resto de los datos en
l//a estructura apuntada por art

// Si no se encuentra, devuelve -1
int posicion =-1;

FILE *f;

struct articulo art_actual;
// El fichero se abre slo para lectura y se espera que exista

f =fopen (nombre, "r");

if (f !=NULL){
bool encuentra =false;

fread (&art_actual, sizeof(struct articulo), 1, f);

while (!feof(f) && !encuentra){ // !feof(f) equivale a (feof(f) !=0)
if (art_actual.codigo ==art->codigo){
encuentra =true;
posicion =ftell (f) - sizeof(struct articulo);
copiararticulo(art_actual, art);
}
else{
fread (&art_actual, sizeof(struct articulo), 1, f);
}
}
fclose (f);
}

return posicion;
}
void BuscarElemento(char *nombre){
art.codigo =leercodigo ();
int posicion =BuscarArticulo (nombre, &art);
if (posicion >=0){
// Existe un articulo con ese codigo
mostrararticulo (art);
}
else{
cout <<"no existe ningn elemento con ese cdigo"<<endl;
}
______________________________________________________________________
_______________________________________________________________________________________
}
void InsertarElemento(char *nombre){
art =leerarticulo ();
int posicion =BuscarArticulo (nombre, &art);
if (posicion >=0){
// Existe un articulo con ese codigo
cout <<"existe articulo con ese cdigo" <<endl;
mostrararticulo (art);
}
else{
// El fichero se abre para escritura al final del mismo. Si no existe se crea
FILE *f =fopen (nombre, "a+");
if (f !=NULL){
fwrite (&art, sizeof(struct articulo), 1, f);
fclose (f);
}
else{
cout <<"Error de apertura del fichero";
}
}
}
void ModificarElemento(char *nombre){
struct articulo art_old, art_new;
leercodigo (art_old.codigo);
int posicion =BuscarElemento (nombre, &art_old);
if (posicion >=0){
// Existe un articulo con ese codigo en la posicion
// El fichero se abre para escritura pero se espera que exista

FILE *f =fopen (nombre, "r+");

if (f !=NULL){
mostrararticulo (art_old);
art_new =leerarticulo(art_old.codigo);
fseek(f, posicion, SEEK_SET);
fwrite (&art_new, sizeof(struct articulo), 1, f);
fclose (f);
}
}
else {
cout <<"No existe ningn articulo con ese cdigo" <<endl;
}
}

______________________________________________________________________
_______________________________________________________________________________________
void CrearFichero (char *nombre){
FILE *f =fopen (nombre, "w");
fclose (f);
}
void main (int argc, char **argv){
// si hay ms de un argumento se asume que es el nombre del fichero sino se
//indicaron argumentos se usa el nombre del fichero por defecto
char *nombre_fichero ="articulos.dat";
if (argc >1){
nombre_fichero =argv[1];
}
bool terminar =false;
char opcion;
while ( !terminar){
opcion =leeropcion();
switch (opcion){
case 'C': CrearFichero(nombre_fichero); break;
case 'L': ListarElementos(nombre_fichero); break;
case 'I': InsertarElemento(nombre_fichero); break;
case 'B': BuscarElemento(nombre_fichero); break;
case 'M': ModificarElemento(nombre_fichero); break;
case 'T': terminar =true;
}
}
}

La funcin leeropcion() muestra un men con 6 opciones: (C)rear fichero, (L)istar
elementos, (I)nsertar elemento, (B)uscar elemento, (M)odificar elemento, (T)erminar y
retorna una eleccin vlida introducida por el usuario.

Ejemplo: el siguiente programa ilustra las operaciones de creacin, adicin eliminacin
fsica y lgica, reporte general y un reporte particular empleando archivo de datos con los
campos: codigo nombre y edad.

#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#include <dos.h>

FILE *f;
//FILE *f1;
______________________________________________________________________
_______________________________________________________________________________________
int op;
struct reg
{
int cod;
char nombre[20];
int edad;
};
void impreg(struct reg y)
{
//despliega por pantalla el contenido de un registro
// clrscr();
printf("\n codigo :%d",y.cod);
printf("\n nombre :%s",y.nombre);
printf("\n edad :%d",y.edad);
};

void limpiar(struct reg y)
{
y.cod=0;
y.nombre[0]='\0';
y.edad=0;
};

void crear(FILE *x)
{
// crea un archivo permitiendo introducir datos en
//el momento de la creacion
char c;
int resp=1;
struct reg aux;
clrscr();
if ((x=fopen("regi.dat","w+"))==NULL)
printf("\nerror en la apertura");
else
{
do
{
// clrscr();
printf("\n codigo :");scanf("%d",&aux.cod);
printf("\n nombre :");scanf("%s",aux.nombre);
printf("\n edad :");scanf("%d",&aux.edad);
fwrite(&aux,sizeof(struct reg), 1,x);
printf("\n seguir s=1/n=0 :");scanf("%d",&resp);
}
while (resp);
fclose(x);
};
______________________________________________________________________
_______________________________________________________________________________________
//getch();
};

int buscar (FILE *x,int y)
{
struct reg aux;
int sw=1;
rewind(x);
while (!feof(x) && sw)
{
fread(&aux,sizeof(struct reg),1,x);
if (aux.cod==y)
sw=0;
};
if (sw)
return -1;
else
return (ftell(x)-sizeof(struct reg));
};

void adicion(FILE *x)
{
// adiciona registros al final del archivo
struct reg aux;
int resp=1;
clrscr();
if ((x=fopen("regi.dat","a+"))==NULL)
printf("\nerror en la apertura");
else
{
do
{
// clrscr();
printf(" adicionando registros al final del archivo");
printf("\n codigo :");scanf("%d",&aux.cod);
printf("\n nombre :");scanf("%s",aux.nombre);
printf("\n edad :");scanf("%d",&aux.edad);
fwrite(&aux,sizeof(struct reg), 1,x);
printf("\n seguir s=1/n=0 :");scanf("%d",&resp);
}
while (resp);
fclose(x);
};
// getch();
};

______________________________________________________________________
_______________________________________________________________________________________
void eliminacion(FILE *x)
{
// elimina registros en forma logica
//grabando el contenido del registro en blanco
clrscr();
struct reg aux;
int resp=1,j,re,clave;
printf("\n eliminacion de registros del archivo");
if ((x=fopen("regi.dat","r+"))==NULL)
printf("error en la apertura");
else
{
while (resp)
{
printf("\n numero de codigo de registro:");
scanf("%d",&clave);
j=buscar(x,clave);
if (j==-1)
printf("\nregistro inexistente");
else
{
printf("\nregistro eliminado");
fseek(x,j,SEEK_SET);
// limpiar(aux);
aux.cod=0;
aux.nombre[0]='\0';
aux.edad=0;

fwrite(&aux,sizeof(struct reg),1,x);
};
printf("\nseguir s=1/n=0");
scanf("%d",&resp);
};
fclose(x);
};
};

void elifis(FILE *x)
{
// elimina en forma fisica los registros que
//han sido eleinados en forma logica
// emplea un archivo temporal
clrscr();
struct reg aux;
int p,q,i;
FILE *temp;
printf("\n esta rutina elimina fisicamente los registros que han");
______________________________________________________________________
_______________________________________________________________________________________
printf("\n sido eliminados en forma logica");
x=fopen("regi.dat","r+");
temp=fopen("extra.dat","w+");
if (x==NULL || temp==NULL)
printf("\n error en apertura de archivos");
else
{
fseek(x,0,SEEK_END);
p=ftell(x);
q=p/sizeof(struct reg);
rewind(x);
printf("\n se tiene %d registros ",q);
for (i=0;i<q;i++)
{
if (aux.cod!=0)
fwrite(&aux,sizeof(struct reg),1,temp);

};
fclose(x);fclose(temp);
remove("regi.dat");
rename("extra.dat","regi.dat");
};
// getch();
};
void reporte(FILE *x)
{
// despliega todos los registros del archivo
struct reg aux;
int p,q,i;
clrscr();
printf("\n reporte general de registros del archivo");
else
{
fseek(x,0,SEEK_END);
p=ftell(x);
q=p/sizeof(struct reg);
rewind(x);
printf("\n se tiene %d registros ",q);

for (i=0;i<q;i++)
{
impreg(aux);
______________________________________________________________________
_______________________________________________________________________________________
};
fclose(x);
};
getch();
};

void reppar(FILE *x)
{
// despliega por pantalla el contenido de un registro especifoco
// la busqueda se realiza por el campo codigo
struct reg aux;
int codo,resp=1,j;
printf("\n reporte particular de registros del archivo");
else
{
while (resp)
{
printf("\n numero de codigo a desplegar :");
scanf("%d",&codo);
j=buscar(x,codo);
if (j==-1)
printf("\n registro inexistente");
else
{
fseek(x,j,SEEK_SET);
impreg(aux);
};
printf("\nseguir s=1/n=0 ");scanf("%d",&resp);
};
fclose(x);
};
// getch();
};

void menu(void);

main()
{
menu();
return 0;
}
______________________________________________________________________
_______________________________________________________________________________________

void menu(void)
{
do
{
clrscr();
printf("\n\n menu de opciones\n\n");
printf(" -----------------------\n\n");
printf("\n 1: crear archivo\n");
printf("\n 2: adicionar registros\n");
printf("\n 3: eliminar registros\n");
printf("\n 4: eliminacion fisica de registros\n");
printf("\n 5: reporte general\n");
printf("\n 6: reporte particular\n");
printf("\n 7: fin de trabajo\n");
printf("\n\n elija su opcion :");
scanf("%d",&op);
switch (op)
{
case 1:printf("\n opcion de creacion del archivo");
crear(f);
break;
case 2:adicion(f);
break;
case 3:eliminacion(f);
break;
case 4: elifis(f);
break;
case 5:reporte(f);
break;
case 6:reppar(f);
break;
};
}
while ((op>=1) && (op<=6));
};

ejemplo: el siguiente programa ilustra el procesamiento de archivos de texto.

#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <string.h>
#include <conio.h>
FILE *f;
void crear( FILE *x)
______________________________________________________________________
_______________________________________________________________________________________
{
//crea un archivo de texto hasta que se presiona la tecla escape
char c;
if ((x=fopen("texto.dat","w"))==NULL)
else
{
printf("\n<esc>para terminar\n");
while ((c=getch())!=27)
{
printf("%c",c);
fputc(c,x);
};
fclose(x);
};
};

void crear1( FILE *x)
{
//crea un archivo de texto con formato hasta que se presiona la tecla retorno
// en un alinea en blanco
char cad[80];
int sw;
if ((x=fopen("texto.dat","w"))==NULL)
else
{
printf("\n<rtn>para terminar en una linea en blanco\n");
while (sw)
{
gets(cad);
if (cad[0]=='\0')
sw=0;
else

// printf("%s",cad);
fputs(cad,x);
};
fclose(x);
};
};

void leer( FILE *x)
{
//lee el archivo de texto todo en un a linea
char c;
if((x=fopen("texto.dat","r+"))==NULL)
______________________________________________________________________
_______________________________________________________________________________________
else
{
printf("\nlectura del archivo\n");
while (!feof(x))
{
c=fgetc(x);
// if (c==13)
// printf("\n");
// else
printf("%c",c);

};
fclose(x);
};
};

void leer1( FILE *x)
{
// lee el archivo de texto con formato
char cad[80];
if((x=fopen("texto.dat","r+"))==NULL)
else
{
printf("\nlectura del archivo\n");
while (!feof(x))
{
fgets(cad,3,x);
printf("\n%s",cad);
};
fclose(x);
};
};

main()
{
// crear(f)
// crear1(f);
leer(f);
leer1(f);
return 0;
}

______________________________________________________________________

Ar Chivos

Загружено:

Сведения о документе

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

Ar Chivos

Загружено:

Авторское право:

Доступные форматы

SIS 1101 METODOLOGIA DE LA PROGRAMACIN II ARCHIVOS

Вам также может понравиться