LENGUAJES DE PROGRAMACION

UNIDAD

5
OPERACIONES CON FICHEROS
5.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

Elaborado por Prof. Jacqueline Lpez y Tala Flores

Depto. Lenguajes y Simulacin - FEC

Pgina 1

LENGUAJES DE PROGRAMACION
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).

5.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

Elaborado por Prof. Jacqueline Lpez y Tala Flores

Depto. Lenguajes y Simulacin - FEC

Pgina 2

LENGUAJES DE PROGRAMACION
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<stdio.h> .

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

Abre el archivo en modo lectura. Si el archivo no existe o no se encuentra se

obtiene un error.

Abre un archivo en modo escritura, si no existe se crea y si existe se destruye

para ser creado nuevamente.

Elaborado por Prof. Jacqueline Lpez y Tala Flores

Depto. Lenguajes y Simulacin - FEC

Pgina 3

LENGUAJES DE PROGRAMACION

Abre 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<stdio.h>
FILE *fpt;
fpt = fopen(c:\\saludos.txt, r);
...
fclose(fpt);
Ejemplo 2:
#include<stdio.h>
FILE *fpt;
fpt = fopen(muestra.txt, w);
...
fclose(fpt);

Elaborado por Prof. Jacqueline Lpez y Tala Flores

Depto. Lenguajes y Simulacin - FEC

Pgina 4

LENGUAJES DE PROGRAMACION
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<stdio.h>
#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);
}
}

5.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.

Elaborado por Prof. Jacqueline Lpez y Tala Flores

Depto. Lenguajes y Simulacin - FEC

Pgina 5

LENGUAJES DE PROGRAMACION

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.

Elaborado por Prof. Jacqueline Lpez y Tala Flores

Depto. Lenguajes y Simulacin - FEC

Pgina 6

LENGUAJES DE PROGRAMACION

5.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.

Elaborado por Prof. Jacqueline Lpez y Tala Flores

Depto. Lenguajes y Simulacin - FEC

Pgina 7

LENGUAJES DE PROGRAMACION

5.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<stdio.h>
#include<stdlib.h>
#include<conio.h>
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

Elaborado por Prof. Jacqueline Lpez y Tala Flores

Depto. Lenguajes y Simulacin - FEC

Pgina 8

LENGUAJES DE PROGRAMACION
/*leer una lnea de texto en minscula y almacenarla en maysculas en un archivo de datos*/
#include<stdio.h>
#include<ctype.h>
#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 <stdio.h>
#include <conio.h>
#include <stdlib.h>
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);

Elaborado por Prof. Jacqueline Lpez y Tala Flores

Depto. Lenguajes y Simulacin - FEC

Pgina 9

LENGUAJES DE PROGRAMACION
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 <stdio.h>
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 <stdio.h>
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 <stdio.h>

Elaborado por Prof. Jacqueline Lpez y Tala Flores

Depto. Lenguajes y Simulacin - FEC

Pgina 10

LENGUAJES DE PROGRAMACION
#include <conio.h>
#include <stdlib.h>
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

FSCANF

Nota: para este ejemplo crear el fichero pedro.txt conteniendo la siguiente

informacin: 40
El fichero datos se crea automticamente si este no est creado.
#include <stdio.h>
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<stdio.h>
#include<conio.h>
#include<stdlib.h>
#include<ctype.h>

Elaborado por Prof. Jacqueline Lpez y Tala Flores

Depto. Lenguajes y Simulacin - FEC

Pgina 11

LENGUAJES DE PROGRAMACION
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))

Elaborado por Prof. Jacqueline Lpez y Tala Flores

Depto. Lenguajes y Simulacin - FEC

Pgina 12

LENGUAJES DE PROGRAMACION
{
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<stdio.h>
#include<conio.h>
#include<stdlib.h>
#include<string.h>
#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;

Elaborado por Prof. Jacqueline Lpez y Tala Flores

Depto. Lenguajes y Simulacin - FEC

Pgina 13

LENGUAJES DE PROGRAMACION
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*/

Elaborado por Prof. Jacqueline Lpez y Tala Flores

Depto. Lenguajes y Simulacin - FEC

Pgina 14

LENGUAJES DE PROGRAMACION

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:
Rosa
Domitila
managua
1235
A
1000.00
0.00
0.00
22/11/2011
Jordy
mayoreo
managua
4569
A
5000.00
0.00
0.00

Elaborado por Prof. Jacqueline Lpez y Tala Flores

Depto. Lenguajes y Simulacin - FEC

Pgina 15

LENGUAJES DE PROGRAMACION
22/11/2011
Franco
Masaya
Masaya
5632
A
456.00
0.00
0.00
22/11/2011
FIN

5.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 fichero
2. SEEK_CUR 1: posicin actual
3. 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

Elaborado por Prof. Jacqueline Lpez y Tala Flores

Depto. Lenguajes y Simulacin - FEC

Pgina 16

LENGUAJES DE PROGRAMACION

Elaborado por Prof. Jacqueline Lpez y Tala Flores

Depto. Lenguajes y Simulacin - FEC

Pgina 17

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

Este es el
1
2 3

texto del fichero

5
6
4

#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
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: texto

Elaborado por Prof. Jacqueline Lpez y Tala Flores

Depto. Lenguajes y Simulacin - FEC

Pgina 18

LENGUAJES DE PROGRAMACION
2. Escribir datos directamente a un archivo de acceso directo
#include<stdio.h>
#include<conio.h>
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

Elaborado por Prof. Jacqueline Lpez y Tala Flores

Depto. Lenguajes y Simulacin - FEC

Pgina 19

LENGUAJES DE PROGRAMACION
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<stdio.h>
#include<conio.h>
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;
}

Elaborado por Prof. Jacqueline Lpez y Tala Flores

Depto. Lenguajes y Simulacin - FEC

Pgina 20

LENGUAJES DE PROGRAMACION

Elaborado por Prof. Jacqueline Lpez y Tala Flores

Depto. Lenguajes y Simulacin - FEC

Pgina 21

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

<stdio.h>
<conio.h>
<ctype.h>
<string.h>
<stdlib.h>

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("
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);

DIRECTORIO TELEFONICO");

Elaborado por Prof. Jacqueline Lpez y Tala Flores

Depto. Lenguajes y Simulacin - FEC

Pgina 22

LENGUAJES DE PROGRAMACION
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();

Elaborado por Prof. Jacqueline Lpez y Tala Flores

Depto. Lenguajes y Simulacin - FEC

Pgina 23

LENGUAJES DE PROGRAMACION
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)<30){
if(busca_Clave2(a,reactivo.nombre)==0){
printf("Telefono : ");gets(reactivo.tele);
fseek(a,0,SEEK_END);

Elaborado por Prof. Jacqueline Lpez y Tala Flores

Depto. Lenguajes y Simulacin - FEC

Pgina 24

LENGUAJES DE PROGRAMACION
fwrite (&reactivo,sizeof(struct DIREC),1,a);
}
else{
printf("\n\nYa existen esos datos!!!");
getch();
}
}
else{
printf("\n\nMximo 25 letras por nombre...");
printf("\n\nEl programa puede daarse si repite este error!!!");
getch();
}
}
/*********************************************************************/
long busca_Clave2(FILE *a,char buscado[]){
long p;
struct DIREC r;
rewind(a);
while(1){
if(fread(&r,sizeof(struct DIREC),1,a)==0)
break;
if(strcmp(r.nombre,buscado)==0){
p=ftell(a)/sizeof(struct DIREC);
return(p);
}
}
return 0;
}
/*********************************************************************/
void consulta2(FILE *a){
char nombre[30];
long p;
struct DIREC r;
printf("\n\nDame el nombre a buscar: ");
strupr(gets(nombre));
p=busca_Clave2(a,nombre);
if(p!=0){
fseek(a,(p-1)*sizeof(struct DIREC),SEEK_SET);
fread(&r,sizeof(struct DIREC),1,a);
printf("\n\n\n");
textcolor(LIGHTGRAY);
cprintf("NOMBRE
TELEFONO");

Elaborado por Prof. Jacqueline Lpez y Tala Flores

Depto. Lenguajes y Simulacin - FEC

Pgina 25

LENGUAJES DE PROGRAMACION
normvideo();
printf("\n%-20s %30s",r.nombre,r.tele);
getch();
}
else{
printf("\n\nLa informacin solicitada no existe ...");
getch();
}
}
/*********************************************************************/
void ordena(FILE *a){
int i=0,j=0,s,t;
struct DIREC r;
struct DIREC temp[100];
struct DIREC temporal;
while(1){
fseek(a,i*sizeof(struct DIREC),SEEK_SET);
if(fread(&r,sizeof(struct DIREC),1,a)==0)
break;
temp[j]=r;
i++;
j++;
}
/*Metodo de la burbuja par a la busqueda*/
for(s=0;s<=1;s++){
temporal=temp[s];
temp[s]=temp[t];
temp[t]=temporal;
}
s=0;
i=0;
while(1){
if(s>=j)
break;
r=temp[s];
fseek(a,i*sizeof(struct DIREC),SEEK_SET);
fwrite (&r,sizeof(struct DIREC),1,a);
s++;
i++;
}
printf("\n\nSus archivos han sido ordenados alfabticamente...");
getch();
}

Elaborado por Prof. Jacqueline Lpez y Tala Flores

Depto. Lenguajes y Simulacin - FEC

Pgina 26

LENGUAJES DE PROGRAMACION

/*********************************************************************/
FILE *pack(FILE *a){
int i=0;
long p;
char clave[30];
struct DIREC r;
FILE *t;
t=fopen ("TMP.txt","wb");
printf("\n\nDame el nombre a dar de baja: ");
strupr(gets(clave));
p=busca_Clave2(a,clave);
if(p!=0){
while(1){
fseek(a,i*sizeof(struct DIREC),SEEK_SET);
if(fread(&r,sizeof(struct DIREC),1,a)==0)
break;
if(strcmp(r.nombre,clave)!=0){
fseek(a,i*sizeof(struct DIREC),SEEK_SET);
fwrite (&r,sizeof(struct DIREC),1,t);
}
i++;
}
fclose (t);
fclose (a);
remove("TELE.txt");
rename("TMP.txt","TELE.TXT");
t=fopen ("TELE.txt","rb+");
printf("\n\nLa informacin solicitada ha sido dada de baja...");
getch();
return(t);
}
else{
printf("\n\nNo existe el nombre...");
getch();
}
return 0;
}
2. MENU DE OPCIONES CON FICHEROS
#include<stdio.h>
#include<stdlib.h>
#include<conio.h>
#include<string.h>

Elaborado por Prof. Jacqueline Lpez y Tala Flores

Depto. Lenguajes y Simulacin - FEC

Pgina 27

LENGUAJES DE PROGRAMACION

void escritura(void); /*funcin prototipo*/

void lectura(void); /*funcin prototipo*/
void main(void)
{
int opcion;
do
{
clrscr();
printf("Men de Opciones: \n");
printf("1. Escritura de un Archivo.\n");
printf("2. Lectura de un Archivo.\n");
printf("3. Salida.\n");
printf("Elija su Opcion: ");
scanf("%d",&opcion);
switch(opcion)
{
case 1:
escritura();
break;
case 2:
lectura();
break;
case 3:
exit(1);
getch();
} /*cierre del switch*/
}while (opcion!=3);/*cierre del do*/
}
/****************FUNCION ESCRITURA ****************/
void escritura(void)
{
FILE *pf;
char nombre[10],texto[200],d,nombre_archivo;
int cont=0;
clrscr();
printf("Dame el nombre del archivo a CREAR: ");
fflush(stdin);
gets(nombre);

Elaborado por Prof. Jacqueline Lpez y Tala Flores

Depto. Lenguajes y Simulacin - FEC

Pgina 28

LENGUAJES DE PROGRAMACION
printf("Ingrese texto al fichero: "); gets(texto);
strcpy(nombre_archivo,"C:\\");
strcat(nombre_archivo,nombre);
strcat(nombre_archivo,".txt");
pf=fopen(nombre_archivo,"w");
while(texto[cont]!='\0')
{
fputc(texto[cont],pf);
cont++;
}
getch();
fclose(pf);
}
/********** LECTURA DESDE EL ARCHIVO ***************/
void lectura(void)
{
FILE *pf;
char nombre[10],nombre_archivo[200],texto[200];
int cont=0,longi,i;
clrscr();
printf("Dame el nombre del archivo que va LEER: ");
fflush(stdin);
gets(nombre);
strcpy(nombre_archivo,"C:\\");
strcat(nombre_archivo,nombre);
strcat(nombre_archivo,".txt");
pf=fopen(nombre_archivo,"r");
while(!feof(pf))
{
texto[cont]= fgetc(pf);
cont++;
}
longi=strlen(texto);
for(i=0;i<longi;i++)
printf("%c",texto[i]);
getch();
fclose(pf);
} /*Fin funcin lectura*/
3. LECTURA DE UN FICHERO UNA LNEA CADA VEZ
#include <stdio.h>
#define MAXLIN 80
void main()

Elaborado por Prof. Jacqueline Lpez y Tala Flores

Depto. Lenguajes y Simulacin - FEC

Pgina 29

LENGUAJES DE PROGRAMACION
{
FILE *fi;
char *tira[MAXLIN];
fi = fopen("cuanto","r");
while (fgets(tira, MAXLIN, fi) != NULL)
puts(tira);
}
4. ESCRIBIR CINCO REGISTROS EN UN FICHERO Y LEERLO POSTERIORMENTE
#include <stdio.h>
struct t_reg {
int num;
char cad[10];
char car;
int crear_fichero ()
{ FILE *fich;
int i, er_dev = 0;
struct t_reg r;
if ((fich = fopen(fichreg.txt", wb")) == NULL)
{ printf ("Error en apertura del fichero para escritura\n");
er_dev = 1;
}
else {
for (i = 0; i < 5; i + + )
{ r.num = i;
r.car=a+1;
printf("D un nombre: ");
gets(r.cad);
fwrite(&r, sizeof(r), 1, fich);
}
fclose (fich);
}
return er_dev;
}
int Ieer_fichero ()
{ FILE *fich;
struct t-reg r;
int er_dev = 0;
if ((fich = fopen(fichreg.txt", rb")) == NULL)
{ printf ( Error en apertura del fichero para lectura \n );
er_ dev = 1.
}
else
{ fread (&r, sizeof(r), 1, fich);
while (! feof(fich))
{ printf ("%d: %s: %c\n" , r.num, r.cad, r.car);
fread (&r, sizeof(r), 1, fich);
}

Elaborado por Prof. Jacqueline Lpez y Tala Flores

Depto. Lenguajes y Simulacin - FEC

Pgina 30

LENGUAJES DE PROGRAMACION
fclose (fich);
}
return er_dev;
}
int main(void)
{ int error;
error = crear_fichero();
if (!error) Ieer_fichero();
}

Elaborado por Prof. Jacqueline Lpez y Tala Flores

Depto. Lenguajes y Simulacin - FEC

Pgina 31