LENGUAJES DE PROGRAMACION

LENGUAJES DE PROGRAMACION

OPERACIONES CON FICHEROS 4.1 Introduccin:Un archivo es una coleccin de informacin que almacenamos en un soporte magntico, generalmente en un disco para poder manipularla en cualquier momento. Tal informacin se almacena en el dispositivo de almacenamiento en la forma de un archivo de datos. Por tanto los archivos de datos nos permiten almacenar informacin de modo permanente y acceder y alterar la misma cuando sea necesario.

Las funciones de entrada y salida (E/S) de las libreras estndar de C, permiten leer y escribir datos a, y desde, archivos y dispositivos.

Existen dos tipos de ficheros:

1. Ficheros de texto

2. Ficheros binarios

Un archivo de texto es una secuencia de caracteres organizados en lneas terminadas por un carcter de nueva lnea. En estos archivos se pueden almacenar canciones, fuentes de programas, base de datos simples, etc. Los archivos de texto se caracterizan por ser planos, es decir, todas las letras tienen el mismo formato y no hay palabras subrayadas, en negrita, o letras de distinto tamao o ancho.Un archivo binario es una secuencia de bytes que tienen una correspondencia uno a uno con un dispositivo externo. As que no tendr lugar ninguna traduccin de caracteres. Adems, el nmero de bytes escritos (ledos) ser el mismo que los encontrados en el dispositivo externo. Ejemplos de estos archivos son Fotografas, imgenes, texto con formatos, archivos ejecutables (aplicaciones), etc.

En c, un archivo es un concepto lgico que puede aplicarse a muchas cosas desde archivos de disco hasta terminales o una impresora. Se asocia una secuencia con un archivo especfico realizando una operacin de apertura. Una vez que el archivo est abierto, la informacin puede ser intercambiada entre este y el programa.

Nota: Un fichero de texto es aquel en el que la informacin se almacena como caracteres, utilizando su cdigo ASCII o similar.Un fichero binario es aquel en el que se almacena informacin binaria como puede ser un cdigo en lenguaje mquina.El tipo de acceso a los ficheros (archivos) de texto puede ser de dos maneras:

1. Acceso secuencial: esto es, que dichos archivos no permiten acceder al punto exacto donde se guardaba la informacin sin antes haber partido desde el principio y sin haber ledo toda la informacin, hasta el punto donde se encontrase la informacin que se buscaba. Leer o escribir datos comenzando siempre desde el principio del archivo.

Aadir datos a partir del final del archivo.

Poco eficiente.2. Acceso aleatorio: Los archivos de acceso aleatorio son ms verstiles (adaptable), permiten acceder a cualquier parte del fichero en cualquier momento, como si fueran arrays en memoria. Las operaciones de lectura y/o escritura pueden hacerse en cualquier punto del archivo. En este caso organiza los datos en bloques de bytes contiguos de informacin, que representan estructuras de datos, arreglos y estructuras). Acceder directamente a cualquier posicin dada de un archivo para actualizar los valores contenidos a partir de dicho punto.

Implica la utilizacin de operaciones nuevas que permitan situarse en cualquier punto del archivo.

Un fichero es una cadena de bytes consecutivos que termina en un carcter especial llamado EOF (End Of File).

4.2 Apertura y Cierre de un archivo:

Se puede conseguir la entrada y la salida de datos a un archivo a travs del uso de la biblioteca de

Funciones; C no tiene palabras claves que realicen las operaciones de E/S. La siguiente tabla da un breve resumen de las funciones que se pueden utilizar. Se debe incluir la librera STDIO.H.

Cuando se trabaja con archivos secuenciales, lo primero es establecer un rea de buffer. Un rea de buffer es un lugar de memoria que se usa para transferir datos desde la memoria a los dispositivos de almacenamiento secundario y viceversa, es aqu que la informacin se almacene temporalmente mientras se transfiere entre la memoria de la computadora y el archivo de datos. Esta rea de buffer se establece de la siguiente manera:

FILE *vp ;

En donde FILE es un tipo especial de estructura que establece el rea de buffer y vp es la variable puntero que indica el principio de esa rea.

El tipo de estructura FILE se define en el archivo #include .

4.3.1 Abrir un archivo:

Antes de abrir un archivo necesitamos declarar un puntero tipo FILE:

FILE *puntero;

fopen(camino, acceso);

fopen(camino, acceso): abre el archivo indicado en el argumento camino. El argumento acceso especfica el modo en que ser abierto el archivo.

Acceso

Descripcin

rAbre el archivo en modo lectura. Si el archivo no existe o no se encuentra se obtiene un error.

wAbre un archivo en modo escritura, si no existe se crea y si existe se destruye para ser creado nuevamente.

aAbre un archivo para aadir informacin al final del mismo. Si el archivo no existe se crea.

r+Abre un archivo en modo lectura y escritura, el archivo debe de existir.

w+Abre un archivo en modo lectura y escritura, si el archivo no existe se crea.

a+Abre un archivo para leer y aadir informacin al mismo. Si no existe se crea.

4.3.2 Cerrar un archivo:

fclose(pf);feof(pf): indica si se ha llegado al final del archivo apuntado por pf, devuelve un valor distinto de cero cuando se intenta leer un elemento del archivo y nos encontramos con un EOF en caso contrario

Una de las tareas principales de fclose() es el vaciado del buffer, que podra haber quedado parcialmente lleno al cerrar el fichero, y que puede ocasionar que realicemos una lectura errnea en el futuro.fclose(pf): cierra el archivo apuntado por pf.

fcloseall( ): cierra todos los archivos que estn abiertos.

Ejemplo 1:

#include

FILE *fpt;

fpt = fopen(c:\\saludos.txt, r);

. . .

fclose(fpt);

Ejemplo 2:

#include

FILE *fpt;

fpt = fopen(muestra.txt, w);

. . .

fclose(fpt);Ejemplo 2: El siguiente ejemplo trata de abrir para lectura y escritura un archivo de datos previamente existente llamado muestra.txt. Si el archivo no se encuentra se generar un mensaje de error de lo contrario se abrir el archivo y se procesara como se indica:

#include

#define NULL 0

void main (void)

{

FILE *fpt;

fpt = fopen(muestra.txt, r+);

if (fpt == NULL)

printf(\n ERROR- No se puede abrir el archivo indicado\n);else {

. . .

fclose(fpt); }}

4.3 Manipulacin de archivos:

Las funciones estndar de E/S, proporcionan la forma ms normal de E/S en un programa C. Permiten escribir y leer datos de un fichero, de la siguiente forma:

1ro. Los datos pueden ser escritos o ledos carcter a carcter:

fgetc(pf);

fputc(carac, pf);

fgetc(pf): lee un carcter desde el archivo apuntado por pf de la posicin indicada por el puntero de lectura y escritura devuelve el carcter leido o un EOF (End Of File) si ocurre un error o detecta el final del archivo.

fputc(carac, pf): escribe el carcter en el archivo apuntado por pf, en la posicin indicada por el puntero de lectura y escritura.

2do. Los datos pueden ser escritos y ledos como cadenas de caracteres (con espacio en blanco) o palabra a palabra:

fgets(cadena1, n, pf);

fputs(cadena1, pf);

fgets(cadena1, n, pf): lee una cadena de caracteres desde el archivo apuntado por pf y la almacena en cadena1, la terminacin \0 es aadida automticamente a la cadena leida, si el valor devuelto es NULL significa que ha ocurrido un error o que se detecto el final del archivo.

fputs(cadena1, pf): copia la cadena .

3ro. Los datos pueden ser escritos y ledos con formato:

fscanf(pf, formato, argumentos);

fprinf(pf, formato, argumentos);

fscanf(pf, formato, argumentos): lee los argumentos con el formato especificado desde el archivo apuntado por pf, las especificaciones de formatos son las mismas que se indicaron para scanf, cada argumento debe ser un puntero a una variable que se corresponda en tipo con el especificado en el formato.

fprintf(pf, formato, argumentos): escribe los argumentos con el formato especificado en el archivo apuntado por pf, las especificaciones de formato son las mismas de la funcin printf.

4to. Los datos pueden ser escritos y ledos utilizando registro o bloques :

fwrite(buffer, longbytes,c,pf);

fread(buffer,longbytes,c,pf);

fread(buffer, longbytes,c,pf): lee hasta c elementos de longitud longbytes, del fichero apuntado por pf y los almacena en el buffer. fwrite(buffer, longbytes,c,pf): escribe hasta c elementos de longitud longbytes, almacenados en el buffer, en el fichero apuntado por pf.

Cabe destacar que al utilizar estas funciones, se almacena una variable (de tipo struct) que representa un bloque de datos o campos; es decir, no se almacena campo por campo. Esta funcin tiene cuatro argumentos: la variable que se desea grabar, su tamao en bytes, la cantidad de variables y el alias del archivo donde se desea almacenar.

4.4 Funciones para el manejo de errores:

feof(pf);

ferror(pf);

feof(pf): indica si se ha llegado al final del archivo apuntado por pf, devuelve un valor distinto de cero cuando se intenta leer un elemento del archivo y nos encontramos con un EOF en caso contrario devuelve un cero.

ferror(pf): verifica si ha ocurrido un error en una operacin con archivos, devuelve un cero si no ha ocurrido un error o un valor distinto de cero en caso contrario.

4.5 Creacin de un archivo de manera secuencial:

Un archivo debe crearse antes de ser procesado. Un archivo secuencial puede crearse de dos formas distintas:

1ra. Crear el archivo directamente, usando un procesador de texto o un editor.

2da. Escribir un programa que introduzca informacin en la computadora y la escriba en un

archivo.

1ra. Crear el archivo directamente, usando un procesador de texto o un editor.

Ejemplo:

#include

#include

#include

void main(void)

{

FILE *pa;

char cad[50];

clrscr();

if((pa=fopen("f:archivo1.txt","r"))==NULL) /*en este caso archivo.txt esta creado en la unidad f*/

{

printf("Error. No se puede abrir el archivo archivo1.txt");

getch();

exit(0);

}

while(!feof(pa)) /*mientras no se ha llegado a fin de archivo*/ {

fgets(cad,50,pa);/*lee una cadena lo almacena en un array de 50 que puede tener

espacio en blanco*/

printf("%s",cad); /*imprime en pantalla lo que se almaceno en cad*/

}

getch();

fclose(pa); /*cierra el archivo*/}

2da. Escribir un programa que introduzca informacin en la computadora y la escriba en un

archivo.

Ejemplo: Creacin de un archivo de datos

/*leer una lnea de texto en minscula y almacenarla en maysculas en un archivo de datos*/

#include#include

#define NULL 0

void main (void)

{

FILE *fpt; /*define un puntero al tipo de estructura predefinida en FILE */

char c;

clrscr();

/*abrir un archivo nuevo solo para escritura*/

fpt = fopen(datos.txt, w); /*en este caso el archivo se guarda en la unidad actual*/if (fpt == NULL)

printf(\n ERROR- No se puede abrir el archivo indicado\n);else { /*leer cada carcter y escribir su mayscula correspondiente en el archivo*/

do

fputc(toupper(c=getchar()),fpt); /*convierte los caracteres a maysculas*/

while(c != \n);

/*cerrar el archivo de datos*/

fclose(fpt);

} /*fin else*/} /*fin main*/

/************************ USO DE FGETS ******************************/

Lee n caracteres de pf o hasta que encuentra un carcter de final de lnea y los almacena en s junto con \0.

Devuelve la cadena leda o NULL si llega a final de fichero.#include

#include

#include

void main() {

FILE *pf;

char vector[50];

clrscr();

pf = fopen("c:\\fichero.txt", "r");/*abre el archivo en modo lectura*/

while (fgets (vector, 50, pf)!=NULL) /*mientras no se ha llegado a fin de archivo*/

printf ("Leido: %s\n", vector);/*imprime el contenido del vector*/

fclose (pf);

getch();

}

/************************ USO DE FSCANF ******************************/

Lee hasta encontrar un blanco o final de lnea. Devuelve el nmero de tems ledos o EOF si llega a final de fichero.#include

void main() {

FILE *pf;

char vector[50];

pf = fopen(c:\\fichero.txt, r); /*Abre el archivo en modo lectura */

while (fscanf (pf, %s, vector) != EOF) /*mientras no se ha llegado a fin de archivo*/

printf (Leido: %s\n, vector); /*imprime cadena a cadena hasta q no sea un EOF*/

fclose (pf);

}/************************ USO DE FSCANF ******************************/

#include

void main() {

FILE *pf;

float precio; int unidades; char pieza[50];

pf = fopen(c: \\fichero.txt, r);

fscanf (pf, %s%d%f, pieza, &unidades, &precio);

printf (Pieza: %s, cantidad: %d y precio: %f\n, pieza, unidades, precio);

fclose(pf);

}

/*Escriba en el archivo fichero.txt lo siguiente*/

Manguera (enter)

2 (enter)

100 (enter)

/************************ USO DE FPRINTF ******************************/

Escribe el contenido de los argumentos.

Devuelve el nmero de tems escritos en el fichero o un nmero negativo en caso de error./*El siguiente programa escribe de datos de distintos tipos en un archivo de texto*/

#include

#include

#include

void main() {

FILE *pf;

float precio; int unidades; char pieza[50];

clrscr();

printf ("Introduce pieza, cantidad y precio:\n");

scanf ("%s%d%f", pieza, &unidades, &precio);

pf = fopen("c:\\fichero.txt", "w");

fprintf (pf, "%s %d %f ", pieza, unidades, precio); /*escribe en el fichero los datos especificados*/

fclose (pf);

getch();

}

/************************ USO DE FPRINTF Y FSCANF ******************************/

Nota: para este ejemplo crear el fichero pedro.txt conteniendo la siguiente informacin: 40El fichero datos se crea automticamente si este no est creado.#include

void main()

{

FILE *fi;

int edad;

fi = fopen("pedro.txt", "r"); /* fi apunta a "pedro.txt, abre el archivo de modo lectura" */ fscanf (fi, "%d", &edad); /* lee desde el archivo de manera secuencial */

fclose (fi); /* Modo aadir */

fi = fopen ("datos.txt", "a"); /* fi apunta a "datos.txt", abre el archivo para aadir al final */ fprintf (fi,"pedro tiene %d\n", edad); /*imprime dentro del archivo*/ fclose(fi);

}

/** PROGRAMA QUE ESCRIBE Y LEE DATOS EN UN FICHERO REGISTRO A REGISTRO HACIENDO USO DE ESTRUCTURAS, CON LA FUNCION FWRITE Y FREAD **/#include

#include

#include

#include

void main(void)

{

/*CREACION DE LA ESTRUCTURA*/

typedef struct

{

char referencia[20];

long precio;

}registro;

/*DECLARACION DE VARIABLES*/

registro reg; /*reg es de tipo registro*/

int bytesreg=sizeof(reg); /*calcula el tamao de un registro*/FILE *pf;

char sprecio[10],respuesta;

pf=fopen("librito.txt","wb");/*ABRIR ARCHIVO DE MODO BINARIO*/system("cls");

/*ENTRADA DE DATOS */

printf("Pulse Ctrl + Z para finalizar (EN MAYUSCULA)\n\n"); /*CTRL+Z indicador de NULL*/printf("Referencia: ");

while(gets(reg.referencia)!=NULL) /*si referencia es distinto de null*/

{

printf("Precio: "); gets(sprecio);reg.precio=atol(sprecio);

/*ESCRIBIR UN REGISTRO AL FICHERO*/

fwrite(&reg,bytesreg,1,pf);

printf("\nReferencia: ");

} /*fin while*/fclose(pf); /*cierra el fichero*/

clearerr(stdin);/*desactiva el indicador eof de stdin*/do

{

printf("Desea visualizar el fichero? (s/n)");

respuesta=tolower(getchar());

fflush(stdin);

}while((respuesta!='s')&&(respuesta!='n'));

/*SALIDA DE DATOS*/

if(respuesta=='s')

{

system("cls");

pf=(fopen("librito.txt","rb"));

fread(&reg,bytesreg,1,pf);

while(!feof(pf))

{

printf("Referencia: %s\n",reg.referencia);

printf("Precio: %ld\n",reg.precio);

/*leer el siguiente registro del fichero*/

fread(&reg,bytesreg,1,pf);

} /*fin while*/

} /*fin if*/getch();

fclose(pf);

}/*fin main*/

El ejemplo anterior lee registros formados por dos campos, referencia y precio y los almacena en un fichero llamado librito.txt. una vez creado el fichero, disponemos de la opcin de visualizar el fichero, registro a registro.

La funcin fwrite(), almacena los datos numricos en formato binario. Esto quiere decir que un int ocupa 2 bytes, un long ocupa 4 bytes, un float ocupa 4 bytes y un doubl ocupa 8 bytes. Ojo no confundir el formato binario empleado para almacenar un dato numrico, con el modo binario en el que se abre un fichero, lo cual solo indica que se va a efectuar una conversin de los finales de lnea y del final de fichero. /****PROGRAMA QUE CREA UN ARCHIVO DE DATOS QUE CONTENGA REGISTROS DE CLIENTES**/

#include

#include

#include

#include

#define CIERTO 1

typedef struct{

int mes;

int dia;

int anio;

}fecha;

typedef struct{

char nombre[80];

char calle[80];

char ciudad[80];

int no_cuenta;

int tipo_cuenta;

float anteriorsaldo;

float nuevosaldo;

float pago;

fecha ultimopago;

}registro;

registro leerpantalla(registro cliente);/*funcin prototipo*/

void escribirarchivo(registro cliente);/*funcin prototipo*/FILE *fpt; /*puntero a estructura*/void main(void)

{

int indicador=CIERTO;

registro cliente;

system("cls");

/*abrir el archivo en modo escritura*/

if((fpt=fopen("registro.txt","w"))==NULL)

{

printf("Error al abrir el archivo !!");

getch();

exit(0);

}

/*Introducir fecha y asignar valores iniciales*/

printf("SISTEMA DE FACTURACION DE CLIENTES - - INICIALIZACION\n\n ");

printf("Introduzca la fecha actual (mm/dd/aaaa): ");

scanf("%d %d %d",&cliente.ultimopago.mes,&cliente.ultimopago.dia,&cliente.ultimopago.anio);

cliente.nuevosaldo=0;

cliente.pago=0;

cliente.tipo_cuenta='A';

/*Bucle principal*/

while(indicador){

/* introducir el nombre del cliente y escribirlo en el archivo*/ printf("\nNombre(introducir \'FIN\'para terminar):");

fflush(stdin);

scanf("%[^\n]",cliente.nombre);

fprintf(fpt,"\n%s\n",cliente.nombre);

/*comprobacin de la condicin de parada*/ if(strcmp(cliente.nombre,"FIN")==0)

break;

cliente=leerpantalla(cliente);

escribirarchivo(cliente);

}/*fin while*/

fclose(fpt);

}

registro leerpantalla(registro cliente)

/*leer el resto de los datos*/

{

printf("Calle: "); fflush(stdin);scanf("%[^\n]",cliente.calle);

printf("Ciudad: "); fflush(stdin);scanf("%[^\n]",cliente.ciudad);

printf("No de cuenta: "); fflush(stdin);scanf("%d",&cliente.no_cuenta);

printf("Saldo Actual: "); fflush(stdin);scanf("%f",&cliente.anteriorsaldo);

return(cliente);

} /*fin main*/void escribirarchivo(registro cliente) /*escribir el resto de los datos en el archivo*/{

fprintf(fpt,"%s\n",cliente.calle);

fprintf(fpt,"%s\n",cliente.ciudad);

fprintf(fpt,"%d\n",cliente.no_cuenta);

fprintf(fpt,"%c\n",cliente.tipo_cuenta);

fprintf(fpt,"%.2f\n",cliente.anteriorsaldo);

fprintf(fpt,"%.2f\n",cliente.nuevosaldo);

fprintf(fpt,"%.2f\n",cliente.pago);

fprintf(fpt,"%d/%d/%d\n",cliente.ultimopago.mes,cliente.ultimopago.dia,cliente.ultimopago.anio);

} /*fin main*/SALIDA DEL PROGRAMA:

RosaDomitilamanagua

1235

A

1000.00

0.00

0.00

22/11/2011

Jordymayoreo

managua

4569

A

5000.00

0.00

0.00

22/11/2011

Franco

MasayaMasaya5632

A

456.00

0.00

0.00

22/11/2011

FIN

4.6 Creacin de un archivo de manera aleatoria:

La funcion fseek() permite tratar los ficheros como vectores, movindose directamente a un byte determinado del fichero abierto por fopen(). En este caso es necesario utilizar funciones que permitan posicionar el puntero del fichero.Los argumentos de fseek() son los siguientes:int fseek (FILE *pf, long int desplazamiento, int modo)

En donde :

pf es el puntero a fichero.

desplazamiento indica la distancia a que debemos movernos desde el punto de comienzo. Este parmetro debe declararse de tipo long (L) y puede ser positivo o negativo (movimiento hacia delante o hacia atrs). modo es el indicador del punto de referencia para el desplazamiento y puede ser:1. SEEK_SET 0: principio del fichero2. SEEK_CUR 1: posicin actual3. SEEK_END 2: final del fichero

La funcin fseek() devuelve el valor 0 si todo ha ido bien, y devuelve el valor -1 si ha habido algn error.

En esta funcin se utilizan las mismas funciones para lectura y escritura de ficheros de texto de acceso secuencial: fscanf fgets fprintf

1. Supongamos que el fichero fichero.txt contiene la cadena Este es el texto del fichero. Este programa lee diversas palabras del mismo:

#include

#include

#include

void main() {

FILE *pf;

char cadena[50];

clrscr();

pf = fopen("c:\\fichero.txt", "r"); /*abre el archivo en modo lectura*/

fscanf (pf, "%s", cadena);/*lee desde el fichero la primera palabra Este*/

printf ("Primera palabra: %s\n", cadena); /*Este*/

fseek (pf, 4, SEEK_CUR); /*el puntero apunta actualmente al inicio del archivo y avanza 4

bytes a la derecha*/

fscanf (pf, "%s", cadena); /*captura la palabra y la guarda en cadena*/

printf ("Tercera palabra: %s\n", cadena); /*texto*/

fseek (pf, -7, SEEK_END); /**/

fscanf (pf, "%s", cadena);

printf ("Ultima palabra: %s\n", cadena); /*fichero*/

fseek (pf, 11, SEEK_SET);

fscanf (pf, "%s", cadena);

printf ("Cuarta palabra: %s\n", cadena); /*texto*/

getch();

fclose (pf);

getch();

}

Salida del programa:

Primera palabra: Este

Tercera palabra: el

ltima palabra: fichero

Cuarta palabra: texto2. Escribir datos directamente a un archivo de acceso directo #include

#include

struct clientedatos{

int numcta;

char papellido[15];

char nombre[10];

int balance;

};

void main(void)

{

struct clientedatos cliente;

FILE *cfptr;

clrscr();

if((cfptr = fopen("credito.txt","w+")) == NULL)

{

printf("El archivo no pudo ser abierto");

getch();

}

else

{

printf("Introduzca nmero de cuenta (1 hasta 100, o 0 para salir)\n\n");

scanf("%d",&cliente.numcta);

while(cliente.numcta != 0)

{

printf("Introduzca Apellido, Nombre y Balance: \n");

scanf("%s %s %d",&cliente.papellido,&cliente.nombre,&cliente.balance);

fseek(cfptr,(cliente.numcta - 1) * sizeof(struct clientedatos), SEEK_SET);

fwrite(&cliente, sizeof(struct clientedatos), 1,cfptr);

printf("Introduzca nmero de cuenta(Para salir presione 0): \n");

scanf("%d",&cliente.numcta);

}

}

fclose(cfptr);

}

Nota: Posiciona el apuntador de posicin de archivo para el archivo referenciado por cfptr, a la posicin de bytes calculada por (cliente.numcta 1) * sizeof(struct clientedatos), el valor de esta expresin se conoce como desplazamiento. Dado que el nmero de cuenta esta entre 1 y 100 pero las posiciones de bytes ene l archivo empiezan en 0, al calcular la posicin de bytes dentro del registro se resta 1 del nmero de cuenta. Entonces para el registro 1 el apuntador de posicin de archivo se define al byte 0 del archivo.

Como leer datos directamente de un archivo de acceso directo

Utilizando la funcin fread para leer un nmero especifico de bytes de un archivo a la memoria. fread (&cliente, sizeof(struct clientedatos), 1, cfptr);/* Lectura secuencial en un archivo de acceso directo */

#include

#include

struct clientedatos{

int numcta;

char papellido[15];

char nombre[10];

int balance;

};

main()

{

struct clientedatos cliente;

FILE *cfptr;

if((cfptr = fopen("credito.dat","r")) == NULL)

{

printf("El archivo no pudo ser abierto");

getch();

}

else

{

clrscr();

printf("%-6s %-16s %-11s %10s\n","CUENTA","P.APELLIDO","NOMBRE","BALANCE");

while(!feof(cfptr))

{

fread(&cliente,sizeof(struct clientedatos),1,cfptr);

if(cliente.numcta != 0)

printf("%-6d %-16s %-11s %10d\n",cliente.numcta,cliente.papellido,cliente.nombre,cliente.balance);

}

}

fclose(cfptr);

getch();

return 0;

}

EJEMPLOS SOBRE FICHEROS:1. AGENDA TELEFONICA HACIENDO USO DE FICHEROS EN C. CON LAS FUNCIONES FSEEK, FREAD, FWRITE.#include

#include

#include

#include

#include

struct DIREC{

char nombre[35];

char tele[20];

} ;

FILE *pack(FILE *a);

void ordena(FILE *a);

void consulta2(FILE *a);

long busca_Clave2(FILE *a,char buscado[]);

void lee(FILE *a);

void imprime(FILE *a);

void main(){

char opcion;

FILE *archivo;

archivo=fopen ("TELE.txt","wb+"); /* usar opcion "wb+" para crear el archivo .txt y despus cambiar a "rb+" */

while(1){

clrscr();

textattr(6+5*5);

clrscr();

textcolor(YELLOW);

cprintf(" DIRECTORIO TELEFONICO");

printf("\n\n");

cprintf(" N");

printf("uevo");

textcolor(YELLOW);

cprintf(" L");

printf("ista");

textcolor(YELLOW);

cprintf(" B");

printf("aja");

textcolor(YELLOW);

cprintf(" C");

printf("onsulta");

textcolor(YELLOW);

cprintf(" O");

printf("rdena");

textcolor(YELLOW);

cprintf(" S");

printf("alir");

gotoxy(1,25);

printf(" *** PRESIONE LA LETRA RESALTADA PARA ESCOGER LA OPCION ***");

gotoxy(1,4);

opcion=toupper(getch());

if(opcion=='S')

break;

switch(opcion){

case 'N':{

lee(archivo);

break;

}

case 'L':{

imprime(archivo);

break;

}

case 'B':{

pack(archivo);

break;

}

case 'C':{

consulta2(archivo);

break;

}

case 'O':{

ordena(archivo);

break;

}

}

}

clrscr();

fclose (archivo);

normvideo();

clrscr();

}

/*********************************************************************/

void imprime(FILE *a){

int r,y=0,c=1;

struct DIREC reactivo;

clrscr();

textcolor(YELLOW);

cprintf("NOMBRE TELEFONO");

normvideo();

rewind(a);

while(1){

r=fread(&reactivo,sizeof(struct DIREC),1,a);

if(r==0)

break;

if((c%2)!=0){

textattr(6+5*5);

/* textcolor(LIGHTGRAY);*/

printf("\n");

cprintf("%d.- %-30s %16s",c,reactivo.nombre,reactivo.tele);

normvideo();

}

else{

textattr(6+5*4);

/* textcolor(WHITE);*/

printf("\n");

cprintf("%d.- %-30s %16s",c,reactivo.nombre,reactivo.tele);

normvideo();

}

if(y==23){

getch();

y=0;

}

y++;

c++;

}

getch();

}

/*********************************************************************/

void lee(FILE *a){

struct DIREC reactivo;

printf("\n\n");

fflush(stdin);

printf("Nombre : ");strupr(gets(reactivo.nombre)); /*convierte a maysculas*/ if(strlen(reactivo.nombre)