Archivos - Fundamentos

Ing Yamil Armando Cerquera Rojas
yacerque@gmail.com
ARCHIVOS EN C
Ing Yamil Armando Cerquera Rojas yacerque@gmail.com
Especialista en Sistemas Universidad Nacional
Docente Universidad Surcolombiana
Neiva - Huila
CONTENIDO
Qu es un archivo?.......................................................................................2
Diferencias con el manejo de pantalla y teclado:.............................................2
Funcin FILE:..........................................................................................2
Apertura de un archivo: fopen().......................................................................3
Comprobar si un archivo est abierto..........................................................4
Cierre de un archivo: fclose()...........................................................................5
Operaciones bsicas con archivos.....................................................................6
Archivos de texto...........................................................................................7
Creacin de un archivo:...............................................................................7
Las funciones fprintf() y fscanf():..................................................................8
Ejemplo: Utilizacin de la funcin fprintf......................................................9
Comprobar fin de archivo feof.................................................................9
Ejemplo: Utilizacin de la funcin fscanf:...................................................10
Las funciones fgets(), fputs(), getc() fgetc(), putc() fputc().......................11
Ejemplo: Uso de la funcin putc...............................................................12
Ejemplo: Uso de la funcin fgetc..............................................................12
Lectura de una cadena de caracteres con la funcin fgets:...........................13
Escritura de una cadena de caracteres con la funcin fputs..........................13
Ejemplo: OPCION A: Uso de fputs y fgets..................................................13
Ejemplo: OPCION B: Uso de fputs y fgets..................................................15
Ejemplo: Uso de la funcin gets, fprintf y fscanf.........................................15
Ejemplo: Uso de la funcin getc y putc......................................................16
Ejemplo: Almacenamiento de estructuras en archivos de tipo texto con fprintf.
...........................................................................................................17
Archivos Binarios..........................................................................................18
Escritura:.................................................................................................18
Fwrite...................................................................................................18
Lectura:...................................................................................................20
Fread....................................................................................................20
Estructuras guardadas en archivos binarios:..................................................21
Acceso directo a registros en archivos binarios..............................................24
fseek y ftell..............................................................................................24
fseek....................................................................................................24
ftell......................................................................................................25
Archivos con Jerarqua de clases..................................................................30
Creacin del objeto.................................................................................31
Universidad Surcolombiana
1de48

yacerque@gmail.com
Apertura del archivo...............................................................................31

Cierre del archivo...................................................................................32
Manipulacin del archivo.........................................................................33
Operadores de lectura / escritura..............................................................33
1. Operador de insercin: <<...................................................................33
2. Operador de extraccin: >>.................................................................35
Mtodos de lectura / escritura..................................................................36
2de48

yacerque@gmail.com
Listado de Ejemplos
Ejemplo 1: Utilizacin de la funcin fprintf.............................................12
Ejemplo 2: Utilizacin de la funcin fscanf:............................................14
Ejemplo 3: Uso de la funcin putc........................................................15
Ejemplo 4: Uso de la funcin fgetc........................................................16
Ejemplo 5: Uso de fputs y fgets sin control de errores al abrir y cerrar.......17
Ejemplo 6: Uso de fputs y fgets con control de errores al abrir y cerrar......17
Ejemplo 7: Uso de fputs y fgets...........................................................18
Ejemplo 8: Uso de la funcin gets, fprintf y fscanf...................................18
Ejemplo 9: Uso de la funcin getc y putc...............................................19
Ejemplo 10: Almacenamiento de estructuras en archivos de tipo texto
haciendo uso de la funcin fprintf....................................................20
Ejemplo 11: Uso de la Funcin fwrite....................................................22
Ejemplo 12: Uso d ela funcin fread.....................................................23
Ejemplo 13: Almacenamiento de estructuras en archivos de binarios.........24
Ejemplo 15: Almacenamiento de estructuras en archivos de binarios.........25
Ejemplo 16: Uso de fflush, fwrite..........................................................26
Ejemplo 17: Uso de fread....................................................................26
Ejemplo 18: Uso de la funcin fseek.....................................................28
Ejemplo 19: Archivos binarios usando la funcin fseek().........................28
Ejemplo 20: Archivos..........................................................................30
Ejemplo 21.......................................................................................42
Ejemplo 22.......................................................................................42
3de48

yacerque@gmail.com
Generalidades:
A menudo se necesita almacenar cierta cantidad de datos de forma
permanente. La memoria del ordenador RAM es voltil, y lo peor, escasa y
cara. De modo que cuando se necesita guardar datos durante cierto tiempo
se tiene que recurrir a sistemas de almacenamiento ms econmicos,
aunque sea a costa de que sean ms lentos.
Durante la historia de los ordenadores se han usado varios mtodos distintos
para el almacenamiento permanente de datos. Al principio se recurri a
cintas de papel perforadas, despus a tarjetas perforadas. A continuacin se
pas al soporte magntico, empezando por grandes rollos de cintas
magnticas abiertas.
Hasta aqu, todos los sistemas de almacenamiento externo eran
secuenciales, es decir, no permitan 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 encontraba la que
se estaba buscando.
Con las cintas magnticas empez lo que con el tiempo sera el acceso
aleatorio a los datos. Se poda reservar parte de la cinta para guardar cierta
informacin sobre la situacin de los datos, y aadir ciertas marcas que
hicieran ms sencillo localizarla.
Pero no fue hasta la aparicin de los discos magnticos cuando sta tcnica
lleg a su sentido ms amplio. En los discos es ms sencillo acceder a
cualquier punto de la superficie en poco tiempo, ya que se accede al punto
de lectura y escritura usando dos coordenadas fsicas. Por una parte la
cabeza de lectura/escritura se puede mover en el sentido del radio del disco,
y por otra el disco gira permanentemente, con lo que cualquier punto del
disco pasa por la cabeza en un tiempo relativamente corto. Esto no pasa con
las cintas, donde slo hay una coordenada fsica.
Con la invencin y proliferacin de los discos se desarrollaron los archivos de
acceso aleatorio, que permiten acceder a cualquier dato almacenado en un
archivo en relativamente poco tiempo.
Actualmente, los discos duros tienen una enorme capacidad y son muy
rpidos, aunque an siguen siendo lentos, en comparacin con la memoria
RAM del PC. El caso de los CD es algo intermedio. En realidad son
4de48

yacerque@gmail.com
secuenciales en cuanto al modo de guardar los datos, cada disco slo tiene
una pista de datos grabada en espiral. Sin embargo, este sistema,
combinado con algo de memoria RAM, proporciona un acceso muy prximo
al de los discos duros.
Qu es un archivo?
Un archivo es un dispositivo de entrada-salida cuyo fin ltimo es guardar

informacin o permitir la recuperacin de informacin guardada previamente.
Los archivos se almacenan en dispositivos de almacenamiento masivo como
el disco duro, diskette, CD-DVD ROM-RW, Memoria flash, etc.
El manejo de los sistemas de almacenamiento de los archivos es gestionado
por el sistema operativo.
Una operacin de lectura o de escritura de un archivo es parecida a una
operacin de lectura o escritura de datos desde el teclado
Operaciones con archivos:
Apertura de archivos: fopen()

Cierre de archivos: fclose()
Lectura de datos de archivos: fscanf()
Escritura de datos en archivos: fprintf()
Es importante indicar que los archivos archivos FILES no son nicamente

los archivos que se guardan en el disco duro o en medios de almacenamiento
masivo, en lenguaje C todos los dispositivos del computador se tratan como
archivos: la impresora, el teclado, la pantalla, etc.
Un archivo se identifica por su nombre, el cual generalmente est compuesto
por:
-
Path: indica la ruta para encontrar el archivo incluyendo la unidad de

almacenamiento donde se halla.
Nombre: es el nombre que identifica los datos guardados en el medio
de almacenamiento masivo.
Extensin: son tres caracteres que sirven para identificar el tipo de
archivo y bsicamente se relaciona con el programa con la cual se crea
el archivo.
Ejemplo: "C:\programacion\yamil.c"
5de48

yacerque@gmail.com
En el caso del ejemplo anterior, el path sera C:\programacion\, para

indicar que el archivo se encuentra en la pariticin C del disco duro dentro de
un directorio llamado programacin, el nombre yamil y la extensin c,
que podra indicar que es un archivo creado con un editor para C.
Un archivo consiste en una secuencia de componentes del mismo tipo, cada
uno de los cuales contiene informacin sobre un elemento. Cada componente
se denomina registro, y cada registro consta de una serie de campos que
pueden ser de distinto tipo.
El registro fsico es la cantidad de informacin que se lee o que se escribe en
cada operacin de lectura o de escritura sobre un archivo. Su tamao
depende del tipo.
Clasificacin de los archivos

En cuanto al tipo de acceso, en C y C++ se pueden clasificar los archivos
segn varias categoras:
1. Dependiendo de la direccin del flujo de datos:
o De entrada: los datos se leen por el programa desde el archivo.
o De salida: los datos se escriben por el programa hacia el archivo.
o De entrada/salida: los datos pueden se escritos o ledos.
2. Dependiendo del tipo de valores permitidos a cada byte:
o De texto: slo estn permitidos ciertos rangos de valores para
cada byte. Algunos bytes tienen un significado especial, por
ejemplo, el valor hexadecimal 0x1A marca el fin de archivo. Si se
abre un archivo en modo texto, no ser posible leer ms all de
un byte con ese valor, aunque el archivo sea ms largo.
o Binarios: estn permitidos todos lo valores para cada byte. En
estos archivos el final del archivo se detecta de otro modo,
dependiendo del soporte y del sistema operativo. La mayora de
las veces se hace guardando la longitud del archivo. Cuando se
quiera almacenar valores enteros, o en coma flotante, o
imgenes, etc, se debe usar este tipo de archivos.
3. Segn el tipo de acceso:
o Archivos secuenciales: imitan el modo de acceso de los antiguos
archivos secuenciales almacenados en cintas magnticas y
o Archivos de acceso aleatorio: permiten acceder a cualquier punto
de ellos para realizar lecturas y/o escrituras.
4. Segn la longitud de registro:
6de48

yacerque@gmail.com
Longitud variable: en realidad, en este tipo de archivos no tiene

sentido hablar de longitud de registro, se puede considerar cada
byte como un registro. Tambin puede suceder que la aplicacin
conozca el tipo y longitud de cada dato almacenado en el
archivo, y lea o escriba los bytes necesarios en cada ocasin.
Otro caso es cuando se usa una marca para el final de registro,
por ejemplo, en archivos de texto se usa el carcter de retorno
de lnea para eso. En estos casos cada registro es de longitud
diferente.
Longitud constante: en estos archivos los datos se almacenan en
forma de registro de tamao constante. En C se usan estructuras
para definir los registros. C dispone de funciones de librera
adecuadas para manejar este tipo de archivos.
Mixtos: en ocasiones pueden crearse archivos que combinen los
dos tipos de registros, por ejemplo, dBASE usa registros de
longitud constante, pero aade un registro especial de cabecera
al principio para definir, entre otras cosas, el tamao y el tipo de
los registros.
Es posible crear archivos combinando cada una de estas categoras, por

ejemplo: archivos secuenciales de texto de longitud de registro variable, que
son los tpicos archivos de texto. Archivos de acceso aleatorio binarios de
longitud de registro constante, normalmente usados en bases de datos. Y
tambin cualquier combinacin menos corriente, como archivos secuenciales
binarios de longitud de registro constante, etc.
En cuanto a cmo se definen estas propiedades, hay dos casos. Si son
binarios o de texto o de entrada, salida o entrada/salida, se define al abrir el
archivo, mediante la funcin fopen en C o mediante el mtodo open de
fstream en C++.
En C++ es algo diferente, el constructor de las clases ifstream, ofstream y
fstream admite los parmetros para abrir el archivo directamente, y tambin
disponemos del mtodo open, para poder crear el stream sin asociarlo con
un archivo concreto y hacer esa asociacin ms tarde.
Diferencias con el manejo de pantalla y teclado:

Es necesario establecer un rea de buffer. Esta rea almacena la informacin
mientras se estn transfiriendo datos desde o hacia el archivo.
7de48

yacerque@gmail.com
Funcin FILE:
C define la estructura de datos FILE en el archivo de cabecera "stdio.h" para
el manejo de archivos. Se debe usar siempre punteros a estas estructuras.
La definicin de sta estructura depende del compilador, pero en general
mantienen un campo con la posicin actual de lectura/escritura, un buffer
para mejorar las prestaciones de acceso al archivo y algunos campos para
uso interno.
Para apuntar al rea de buffer se utiliza la siguiente declaracin:
FILE *punt_archivo;
Donde:
FILE es un tipo especial de estructura que establece el rea del

buffer. Contiene toda la informacin que necesitan el resto de
funciones que trabajan con archivos, como el modo del archivo, los
buffers del archivo, errores... (Funcin de la librera stdio.h).
punt_archivo es una variable de tipo puntero que apunta al
comienzo del rea del buffer.
El puntero FILE *
Todas las funciones de estrada/salida estndar usan este puntero para
conseguir informacin sobre el fichero abierto. Este puntero no apunta al
archivo sino a una estructura que contiene informacin sobre l.
Esta estructura incluye entre otras cosas informacin sobre el nombre del
archivo, la direccin de la zona de memoria donde se almacena el fichero,
tamao del buffer.
Como dato curioso se adjunta la definicin de la estructura FILE definida en
el fichero stdio.h:
typedef struct
{ int _cnt;
char *_ptr;
char *_base;
int _bufsiz;
int _flag;
8de48

yacerque@gmail.com
int _file;
char *_name_to_remove;
int _fillsize;
} FILE;
Typedef struct
{ int eda ;
Float alt;
Char nom[10] ;
} yamil ;
Yamil xx,yy ;
Apertura de un archivo: fopen()

Esta funcin sirve para abrir y crear archivos en disco. El valor de retorno es
un puntero a una estructura FILE.
Esta operacin se debe realizar antes de cualquier operacin con un archivo.
Una vez abierto el archivo, y hasta que ste se cierre, se pueden
realizar tantas operaciones como se deseen sin necesidad de volver a
abrirlo.
El objetivo de abrir un archivo es:
Asociar el nombre del archivo fsico con el rea del buffer.
Especificar el uso que se le va a dar al archivo (lectura, escritura,
lectura-escritura, en modo texto, binario ...)
La funcin open usa dos parmetros. El primero es el nombre del archivo
que contiene el archivo. El segundo es el modo, una cadena que indica el
modo en que se abrir el archivo: lectura o escritura, y el tipo de datos que
contiene: de texto o binarios.
Prototipo de la funcin:
FILE *fopen (char * nombre_completo_archivo, char *modo);
nombre_completo_archivo (cadena de caracteres): es el nombre del

archivo fsico sobre el que se desea trabajar.
9de48

yacerque@gmail.com
Incluyendo el camino completo y la unidad en caso de que fuera

necesario.
- El valor de retorno de fopen():
xito: El puntero al comienzo del rea del buffer.
Error: devuelve NULL si no se pudiera abrir el archivo.
modo (cadena de caracteres): indica el uso que tendr el archivo o
archivo
Apertura de un archivo: Modo

r
Abre un archivo existente para lectura.

Crea un archivo nuevo (o borra su contenido si existe) y lo abre para
w
escritura.
Abre un archivo (si no existe lo crea) para escritura. El puntero se sita
a al final del archivo, de forma que se puedan aadir datos sin borrar los
existentes.
En cuanto a los valores permitidos para los bytes, se puede aadir
modificadores a la cadena de modo tal como sigue:
t: modo texto. Normalmente es el modo por defecto. Se suele omitir.

b: modo binario.
En ciertos sistemas operativos no existe esta distincin, y todos los archivos

son binarios.
Ejemplos de combinaciones:
rb+ - Abre el archivo en modo binario para lectura y escritura.

w+ - Crea (o lo borra si existe) un archivo para lectura y escritura.
rt - Abre un archivo existente en modo texto para lectura.
En resumen en el lenguaje de programacin C, los archivos admiten seis

modos en cuanto a la direccin del flujo de datos:
r: slo lectura. El archivo debe existir.

w: se abre para escritura, se crea un archivo nuevo o se sobrescribe si
ya existe.
a: aadir, se abre para escritura, el cursor se sita al final del archivo.
Si el archivo no existe, se crea.
r+: lectura y escritura. El archivo debe existir.
10de48

yacerque@gmail.com
w+: lectura y escritura, se crea un archivo nuevo o se sobrescribe si ya

existe.
a+: aadir, lectura y escritura, el cursor se sita al final del archivo. Si
el archivo no existe, se crea.
Comprobar si un archivo est abierto

Algo bien importante despus de abrir un archivo es comprobar si realmente
est abierto. El sistema no es infalible y pueden producirse errores: el
archivo puede no existir, estar daado o no tener permisos de lectura.
Si se intenta realizar operaciones sobre un puntero tipo FILE cuando no se ha
conseguido abrir el archivo puede haber problemas. Por eso es importante
comprobar si se ha abierto con xito.
Si el archivo no se ha abierto el puntero pfich (puntero a FILE) tendr el
valor NULL, si se ha abierto con xito tendr un valor distinto de NULL. Por lo
tanto para comprobar si ha habido errores se fija en el valor del puntero:
FILE *pfich;
pfich=fopen(c:\\yamil.txt) ;
if (pfich==NULL)
{
printf( "No se puede abrir el archivo.\n" );
exit(1);
}
Si pfich es igual a NULL, significa que no se ha podido abrir por algn error.
Lo ms conveniente es salir del programa. Para salir se utiliza la funcin
exit(1), el 1 indica al sistema operativo que se han producido errores.
Cierre de un archivo: fclose()

Es importante cerrar los archivos abiertos antes de finalizar la aplicacin.
Esta funcin sirve para eso. Cerrar un archivo almacena los datos que an
estn en el buffer de memoria, y actualiza algunos datos de la cabecera del
archivo que mantiene el sistema operativo. Adems permite que otros
programas puedan abrir el archivo para su uso. A menudo, los archivos no
pueden ser compartidos por varios programas.
Un valor de retorno cero indica que el archivo ha sido correctamente cerrado,
si ha habido algn error, el valor de retorno es la constante EOF. El
11de48

yacerque@gmail.com
parmetro es un puntero a la estructura FILE del archivo que se quiere

cerrar.
Su objetivo es liberar el espacio del rea del buffer.
Se escriben a disco todos los datos que an queden en el buffer, se
desconecta el archivo del programa y se libera el puntero al archivo.
Es obligatorio cerrar un archivo cuando se haya terminado con su uso
dentro del programa.
Siempre que se quiera cambiar la forma de acceso al archivo, tambin
ser necesario cerrarlo y volverlo a abrir especificando el nuevo tipo de
acceso para el manejo del archivo.
Un archivo no puede abrirse ms de una vez sin antes haberlo
cerrado.
Prototipo de la funcin:
int fclose(FILE *puntero_al_archivo);
puntero_al_archivo: es el puntero a archivo devuelto por la funcin
fopen() al abrir el archivo que ahora se desea cerrar.
El valor devuelto por la funcin es:
0: si el archivo se cerr con xito.
1: si ocurri algn tipo de error al cerrar el archivo
Independientemente del valor de retorno, el archivo se cierra.
Un error tpico es que el disco se ha llenado y no se ha podido
vaciar el buffer con la consiguiente prdida de datos.
if (fclose(pfich) != 0)
printf( "Problemas al cerrar el archivo \n" );
Operaciones bsicas con archivos

#include <stdio.h>
void main(void)
{ FILE *pfich;
pfich = fopen(a:\datos.dat,w);
if (pfich == NULL)
{ printf(\n Error al abrir el archivo);
exit(1); }
if (fclose(pfich) != 0)
{ printf(\n Error al cerrar el archivo );
Declaracin de un puntero a archivo

Apertura en modo escritura (w) del archivo
datos.dat
Comprobacin de que la apertura ha sido
incorrecta
Se utiliza el archivo para escritura Al acabar
de usar el archivo
Cierre del archivo y comprobacin de si se
ha realizado correctamente
12de48

yacerque@gmail.com
exit(1); }
}
Tipos de archivo:
Texto
o Archivos ASCII planos, obtenidos y manejados desde programa
utilizando cadenas de caracteres.
o Se pueden ver con un editor de texto.
Binario
o Archivos con los datos guardados como copia exacta de la memoria
del ordenador (binario).
o Slo comprensible desde un programa que sepa qu tipos de
o datos contiene el archivo y de qu forma estn guardados.
o Si se visualizan con un editor de texto no son comprensibles.
o Los archivos binarios y los programa que utilizan archivos binarios
no son fcilmente portables a otros ordenadores y otros
compiladores (el tamao de las variables puede variar).
Archivos de texto
Los archivos de texto son legibles y fciles de portar, pero ocupan ms
espacio para almacenar la informacin. Los archivos binarios no son
legibles con un editor de texto y no son portables de un ordenador a otro,
pero ocupan menos espacio.
Ejemplo: Cuatro dgitos numricos 2563, que se desee guardar.
Como archivo texto ocupa 4 bytes as:
2
5
6
3
00110010 00110101 00110110 00110011
Como archivo binario ocupara 2 bytes en programacin de 16 bit`s as:
2563
00001010 00000011
13de48

yacerque@gmail.com
Creacin de un archivo:
Un archivo secuencial debe ser creado antes de ser procesado.
Formas de crear un archivo:
o Directamente: Mediante el uso de un editor de texto (archivos de
texto).
o Indirectamente: Mediante un programa que reciba informacin, la
procese y la guarde en un archivo (texto o binario).
La lectura y escritura de archivos vara segn el tipo de archivos:
Texto: fprintf, fscanf, getc, putc, fgets, fputs
Binarios: fwrite, fread, fseek
Son los archivos que contienen caracteres ASCII.
Los archivos pueden guardar cadenas de caracteres:
Es posible utilizar las funciones de biblioteca utilizadas para escribir y/o
leer cadenas.
La diferencia est en que ahora cuando se utilicen estas funciones hay
que incluir el puntero al buffer del archivo
o putc(carcter,puntero)
o getc(puntero)
o fputs(cadena,puntero)
o fgets(cadena,numero de caracteres,puntero)
o fprintf(puntero,cadena de control,variables)
o fscanf(puntero, cadena de control,variables)
Las funciones fprintf() y fscanf():

Las propias funciones se encargan de realizar las conversiones de formato
que son necesarias para poder transformar los valores binarios usados
internamente en el ordenador a cadenas de caracteres usadas en los
archivos de texto.
fprintf():
El funcionamiento es idntico al de printf() salvo que ahora es
necesario indicar en qu archivo ha de escribir.
Valor retornado:
o xito: devuelve el nmero de bytes que ha escrito
o Fracaso: devuelve EOF
14de48

yacerque@gmail.com
Sintaxis:
int fprintf(FILE *fichero, const char *formato, ...);
La funcin fprintf funciona igual que printf en cuanto a parmetros, pero la
salida se dirige a un archivo en lugar de a la pantalla.
fscanf():
El funcionamiento es idntico al de scanf() salvo que ahora es
necesario indicar de qu archivo ha de leer.
Valor retornado (cuando slo se lee un valor):
o xito: devuelve el valor 1 si ha ledo correctamente
o Fracaso: devuelve 0 si ha ocurrido un error en la lectura por una
mala especificacin de formato.
o EOF: si no se ha ledo nada porque se ha llegado al final del
archivo.
Sintaxis:
int fscanf(FILE *fichero, const char *formato, ...);
La funcin fscanf funciona igual que scanf en cuanto a parmetros, pero la
entrada se toma de un archivo en lugar del teclado.
Ejemplo 1: Utilizacin de la funcin fprintf.
En este ejemplo cada vez que se ejecute el programa se crea de nuevo el
archivo con el nombre yamil.txt sobre la raz del disco duro etiquetado
como C. Si ya existen datos previamente guardados, es decir el archivo ya
existe, los datos almacenados se perdern y se crear uno nuevo con los tres
datos que se piden al usuario ingrese por teclado.
#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
void main()
{ int n=3,
i=1;
FILE *pfich;
int dato;
clrscr();
/* Nmero de datos a grabar*/

/* Puntero al archivo */
15de48

yacerque@gmail.com
pfich = fopen("c:\\yamil.txt", "w+");
if (pfich == NULL)
{ printf("Error: No se puede abrir el archivo "\yamil.txt\"\n");
getch();
exit(1);
}
while (i++<=3)
/* Lee tres valores numricos de tipo entero*/
{ printf("Digite un dato ");
scanf("%d",&dato);
n = fprintf(pfich,"%6d",dato);
/* Guarda el dato ledo con el formato*/
}
if( fclose(pfich) != 0)
{ printf("Error al cerrar el archivo\n"); getch(); exit(1);
}
getch();
}
Para el anterior ejemplo, en caso de no existir el archivo yamil.txt sobre la

raz root del disco duro en su particin c, no habra problema porque lo
creara y adicionara los tres datos enteros ledos por teclado. Si los datos
ledos corresponden al 125, 124, 123 el archivo al abrirlo mostrara los datos
as. Ntese que los espacios corresponden al formato dado de %6d.
125
124
123
Comprobar fin de archivo feof

Cuando se trabaja con el bucle while, para leer datos desde un archivo, la
lectura se realiza hasta que se encuentre el final del archivo. Para detectar el
final del archivo se pueden trabajar de dos formas:
con la funcin feof()

comprobando si el valor de una variable letra de tipo char es EOF.
En el ejemplo ha usado la funcin feof. Esta funcin es de la forma:

int feof(FILE *archivo);
Esta funcin comprueba si se ha llegado al final del archivo en cuyo caso

devuelve un valor distinto de 0. Si no se ha llegado al final del archivo
devuelve un cero. Por eso se usa del siguiente modo:
while ( feof(archivo)==0 )
while ( !feof(archivo) )
16de48

yacerque@gmail.com
La segunda forma consiste en comprobar si el carcter ledo es el de fin de

archivo EOF:
while ( letra!=EOF )
Cuando se trabaja con archivos de texto no hay ningn problema, pero si se

est manejando un archivo binario se puede encontrar EOF antes del fin de
archivo. Por eso es mejor usar feof.
Ejemplo 2: Utilizacin de la funcin fscanf:
/* Programa: Lee el archivo "yamil.txt" que contiene nmeros en punto flotante y calcula su
suma.*/
#include <stdio.h>
void main(void)
{ int n;
/*variable para almacenar el valor devuelto por fscanf*/
FILE *pfich;
/* Puntero al archivo */
double dato;
/* Almacena el dato ledo del archivo */
double sum_tot;
/* Suma de los datos */
pfich = fopen("c:\\yamil.txt", "r+");
if (pfich == NULL)
{ printf("Error: No se puede abrir el archivo \"yamil.txt\"\n"); exit(1); }
sum_tot = 0;
/* Inicializacin de la suma antes de entrar en el bucle*/
n = fscanf(pfich,%lf",&dato);
while (n!=EOF && n!=0)
/* termina en cuanto ocurra un error de lectura*/
{ sum_tot+=dato;
/* o digite el valor de cero 0
n = fscanf(pfich,%lf", &dato);
/* Lee un dato del archivo
}
printf("El valor de la suma es: %lf\n", sum_tot);
if( fclose(pfich) != 0)
{ printf("Error al cerrar el archivo\n"); exit(1); }
}
Si el archivo yamil.txt contiene:

1.3
3.4
4.5
123.4
El resultado sera:
El valor de la suma es: 132.600000
17de48

yacerque@gmail.com
Las funciones fgets(), fputs(), getc() fgetc(), putc()

fputc()
Son funciones que escriben o leen un carcter (fgetc(), getc(), fputc(),
putc()) o cadenas de caracteres (fgets(), fputs())
No realizan conversin de formatos (todo se hace con caracteres)
Lectura de un carcter:
int fgetc(FILE *puntero_a_archivo)
int getc(FILE *puntero_a_archivo)
Leen el siguiente carcter del archivo.
Valor de retorno:
xito: el carcter ledo
Fracaso: Si llega al final de archivo u ocurre un error, el valor de
retorno es EOF.
Escritura de un carcter:
int fputc(int car, FILE * puntero_a_archivo)
int putc(int car, FILE * puntero_a_archivo)
Escriben el carcter car en el archivo
puntero_a_archivo.
Valor de retorno:
xito: el propio carcter escrito
Error: EOF
al
que
apunta
Ejemplo 3: Uso de la funcin putc

Guarda en el archivo yamil.txt caracteres pulsados en el teclado hasta que
se presione la tecla enter. Este archivo es guardado en la raz de la unidad C.
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
void main(void)
{ FILE *punt;
char c;
punt=fopen("c:\\yamil.txt","w");
if (punt==NULL)
18de48

yacerque@gmail.com
{ printf("\n Error NO SE PUEDE ABRIR EL ARCHIVO"); exit(1); }
do
{ c = toupper(getchar());
putc(c, punt);
} while (c != '\n');
if (fclose(punt) != 0)
{ printf("Error al cerrar el archivo"); exit(1); }
}
Ejemplo 4: Uso de la funcin fgetc

Imprime el contenido del archivo cuyo nombre se pide al usuario lo digite
por teclado.
#include <stdio.h>
#include <conio.h>
#define TAM_CAD 256
void main(void)
{ char nom_fich[TAM_CAD];
/* Nombre del archivo que se va a abrir */
char letra;
/* carcter ledo desde el archivo y escrito en pantalla */
FILE *pfich;
/* Puntero al archivo que se imprime */
printf("Introduzca el nombre del archivo que desea imprimir: ");
gets(nom_fich);
pfich = fopen(nom_fich, "r");
if (pfich == NULL)
{ printf("Error al intentar abrir el archivo \"%s\"\n", nom_fich);
exit(1); }
letra = fgetc(pfich);
while(letra != EOF)
{ printf("%c", letra);
letra = fgetc(pfich);
}
fclose(pfich);
/* Cierra el archivo */
getch();
}
Lectura de una cadena de caracteres con la funcin fgets:

char * fgets(char *cadena, int tam_cad, FILE *puntero_a_archivo).
Lee
una
cadena
de
caracteres
del
archivo
apuntado
por
puntero_a_archivo y la almacena en cadena.
La lectura se acaba cuando se encuentra el carcter \n (que S se escribe
en la cadena), cuando se encuentra el fin de archivo (en este caso no se
escribe \n en la cadena) o cuando se han ledo tam_cad caracteres. En
19de48

yacerque@gmail.com
todos estos casos, se escribe un carcter \0 en la cadena a continuacin

del ltimo carcter ledo.
Valor de retorno:
xito: es un puntero a la cadena leda.
Fracaso: NULL, si se llega al final de archivo u ocurre un error
Escritura de una cadena de caracteres con la funcin fputs

int fputs(const char *cadena, FILE *puntero_a_archivo)
Escribe la cadena en el archivo al que apunta puntero_a_archivo SIN EL

\0 DEL FINAL.
Valor de retorno:
Exito: nmero positivo si se ha escrito la cadena correctamente
Error: EOF
Ejemplo 5: Uso de fputs y fgets sin control de errores al abrir y cerrar

Lectura de una cadena desde el teclado, escritura en un archivo y lectura de
esa cadena desde el archivo recin creado.
Suponiendo que no hay ningn tipo de error ni al abrir el archive ni al
cerrarlo.
#include <stdio.h>
#include <ctype.h>
#include <conio.h>
void main(void)
{ FILE *punt;
char cadena1[80], cadena2[80];
clrscr();puts("\n Introduzca una cadena de caracteres:\n");
gets(cadena1);
punt=fopen("c:\yamil.txt","w");
fputs(cadena1,punt);
fclose(punt);
punt=fopen("c:\yamil.txt","r");
fgets(cadena2,80,punt);
fclose(punt);
puts("\nYa se ha ledo el archivo y contiene:\n");
puts(cadena2);
getch();
}
Ejemplo 6: Uso de fputs y fgets con control de errores al abrir y cerrar

#include <stdio.h>
20de48

yacerque@gmail.com
#include <ctype.h>
#include <conio.h>
void main(void)
{ FILE *punt;
char cadena[80];
char cadena2[80];
punt=fopen("c:\yamil.txt","w");
if (punt==NULL)
{ printf("\n Error al intentar abrir el archivo");
exit(1);
}
puts("\n Introduzca una cadena de caracteres:\n"); gets(cadena);
fputs(cadena,punt);
{ printf("Error de archivo"); exit(1); }
punt=fopen("c:\yamil.txt","r");
if (punt==NULL)
{ printf("\nerror de apertura"); exit(1); }
{ printf("Error al cerrar"); exit(1); }
puts("\nYa se ha ledo el archivo y contiene:\n"); puts(cadena2);
getch();
}
Ejemplo 7: Uso de fputs y fgets

Lectura de una cadena desde el teclado, escritura en un archivo y lectura de
esa cadena desde el archivo yamil.txt
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <conio.h>
void main(void)
{ FILE *punt;
char cadena[80];
char cadena2[80];
punt=fopen("c:\yamil.txt","w+");
if (punt==NULL)
{ printf("\n Error - NO SE PUEDE ABRIR EL ARCHIVO PARA ESCRIBIR"); exit(1); }
puts("\n Introduzca una cadena de caracteres:\n"); gets(cadena);
fputs(cadena,punt);
/* Es necesario volver a apuntar al principio del archivo con el puntero */
if (fclose(punt)!=0)
{ printf(Error al cerrar); exit(1); }
puts("\n El archivo contiene:\n"); puts(cadena2);
getch();
21de48

yacerque@gmail.com
Ejemplo 8: Uso de la funcin gets, fprintf y fscanf.

#include <stdio.h>
#include <ctype.h>
#define TAM 80
void main(void)
{ FILE *punt;
char cadena[TAM];
char cadena2[TAM];
char nombre_archivo[TAM];
int n;
printf(Introduzca el nombre del archivo);
gets(nombre_archivo);
punt=fopen(nombre_archivo,"w");
if (punt == NULL)
{ printf("\n Error al abrir el archvio para escribir"); exit(1); }
puts("\n Introduzca una cadena de caracteres:\n");
gets(cadena);
fprintf(punt,"%s\n",cadena);
puts("\n Introduzca una cadena de caracteres:\n");
{ printf(Error al cerrar el archivo ); exit(1); }
punt=fopen(nombre_archivo,"r");
if (punt == NULL)
{ printf("\n Error al abrir el archivo para escribir"); exit(1); }
n = fscanf(punt,"%[^\n]\n",cadena2);
if (n == EOF || n == 0)
{ printf(Error al leer la cadena 2); exit(1); }
puts(cadena2);
{ printf(Error al cerrar el archivo ); exit(1); }
}
Ejemplo 9: Uso de la funcin getc y putc

Lectura de un archivo tipo texto guardado en origen.txt y escritura de su
contenido en un archivo destino.txt suprimiendo todas las vocales del texto
origen.
#include <stdio.h>
int main()
{ FILE *origen, *destino;
char letra;
origen=fopen("origen.txt","r");
destino=fopen("destino.txt","w");
if (origen==NULL || destino==NULL)
{ printf( "Problemas con los archivos.\n" );
exit( 1 );
}
22de48

yacerque@gmail.com
letra=getc(origen);
while (feof(origen)==0)
{ if (!strchr("AEIOUaeiou",letra)) putc( letra, destino );
letra=getc(origen);
}
if (fclose(origen)!=0)
printf( "Problemas al cerrar el archivo origen.txt\n" );
if (fclose(destino)!=0)
printf( "Problemas al cerrar el archivo destino.txt\n" );
}
Si el archivo origen.txt tiene la siguiente informacin

El profesor yamil armando cerquera
Es docente del programa de ingeniera electrnica
Y orienta el curso taller de programacin
El archivo destino.txt contendr lo siguiente despus de aplicado el cdigo
anterior.
l prfsr yml rmnd crqr
s dcnt dl prgrm d ngnr lctrnc
Y rnt l crs tllr d prgrmcn
Si se hubiera querido quitar tambin las vocales tildadas cambie lo siguiente:
if (!strchr("AEIOUaeiou",letra)) putc( letra, destino );
Ejemplo 10: Almacenamiento de estructuras en archivos de tipo texto
haciendo uso de la funcin fprintf.
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define N 2
/* Dimensin de los vectores (nmero de productos) */
typedef struct
/* Declaracin de una estructura para los productos */
{ char nombre[12];
int estatura;
} PROD;
void main(void)
{ PROD producto[N];
/* Vector de productos en el almacn */
int i;
/* contador*/
FILE *f;
/* puntero f a la zona de buffer */
/* Se inicializa el vector con los siguientes datos */
strcpy(producto[0].nombre,"Yamil Cerquera");
producto[0].estatura=179;
strcpy(producto[1].nombre,"Armando Rojas");
23de48

yacerque@gmail.com
producto[1].estatura=180;
/* Se Crea el archivo */
f = fopen("c:\\yamil.txt,"w");
if (f ==NULL)
{ printf("Error al crear el archivo datos.txt\n");
exit(1);
}
for (i = 0; i<N; i++)
{ fprintf(f,"%s\n",producto[i].nombre);
fprintf(f,"%6d\n",producto[i].estatura);
}
fclose(f);
}
Una vez ejecutado el programa, se crea un archivo en la raz del disco duro
C, el cual contendr la siguiente informacin.
Resultado: al abrir el archivo c:\datos.txt con un editor de texto ver los
siguientes 35 caracteres.
Yamil Cerquera
179
Armando Rojas
180
Archivos Binarios
Los archivos binarios se utilizan para almacenar la informacin como una
copia exacta de la memoria del ordenador.
Normalmente, no se pueden ver con un editor de texto, pues sera una
casualidad que los bytes que contienen fuesen caracteres legibles.
til cuando se desea guardar en un archivo bloques de informacin. Permite
escribir los bloques de una sola vez sin necesidad de escribir cada uno de sus
componentes.
Problema de portabilidad
Permiten el acceso directo a los datos en el archivo. En estos casos se
utilizan las funciones fwrite() y fread():
Ambas funciones hacen un acceso directo a la memoria del ordenador a
partir de la direccin donde inicia la estructura de tipo FILE.
24de48

yacerque@gmail.com
Escritura:
Fwrite
Empecemos con fwrite, que nos permite escribir en un archivo. Esta funcin
tiene el siguiente formato:
size_t fwrite(void *estructura, size_t tamano, size_t numero, FILE *parchivo);
buffer - variable que contiene los datos que vamos a escribir en el

archivo.
tamano - el tamao del tipo de dato a escribir. Puede ser un int, un
float, una estructura, ... Para conocer su tamao usamos el operador
sizeof.
numero - el nmero de datos a escribir.
parchivo - El puntero al archivo sobre el que trabajamos.
Para que quede ms claro examine el siguiente ejemplo: un programa de

agenda que guarda el nombre, apellido y telfono de cada persona.
Ejemplo 11: Uso de la Funcin fwrite
#include <stdio.h>
#include <conio.h>
struct
{
char nombre[20];
char apellido[20];
char telefono[15];
} registro;
int main()
{ FILE *archivo;
archivo = fopen( "c:\\yamil.txt ", "a" );
do
{ printf( "Nombre: " ); fflush(stdout); gets(registro.nombre);
if (strcmp(registro.nombre,""))
{ printf( "Apellido: " ); fflush(stdout); gets(registro.apellido);
printf( "Telfono: " ); fflush(stdout); gets(registro.telefono);
fwrite( &registro, sizeof(registro), 1, archivo );
}
} while (strcmp(registro.nombre,"")!=0);
fclose( archivo );
getch();
}
25de48

yacerque@gmail.com
NOTA: El bucle termina cuando el 'nombre' se deja en blanco.

Este programa guarda los datos personales mediante fwrite usando la
estructura registro. Se abre el archivo en modo 'a' (append, aadir), para
que los datos que se incorporan, lo hagan al final del archivo.
Una vez abierto se abre con un bucle do-while mediante el cual se introducen
los datos. Los datos se van almacenando en la variable registro (que es una
estructura). Una vez se tienen todos los datos de la persona, se escriben en
el archivo con fwrite:
fwrite( &registro, sizeof(registro), 1, archivo );
&registro - es la variable (en este caso una estructura) que contiene la

informacin a guardar en el archivo.
sizeof(registro) Se utiliza para saber cul es el nmero de bytes que
desea guardar, el tamao en bytes que ocupa la estructura.
1 - indica que slo se guarda un elemento. Cada vez que se recorre el
bucle se guarda un slo un elemento.
archivo - el puntero FILE al archivo donde se desea escribir.
Lectura:
Fread
La funcin fread se utiliza para sacar informacin de un archivo. Su formato
es:
size_t fread(void *buffer, size_t tamano, size_t numero, FILE *parchivo);
Siendo buffer la variable donde se van a escribir los datos ledos del archivo
parchivo.
El valor que devuelve la funcin indica el nmero de elementos de tamao
'tamano' que ha conseguido leer. Se puede pedir a fread que lea 10
elementos (numero=10), pero si en el archivo slo hay 6 elementos fread
devolver el nmero 6.
Siguiendo con el ejemplo anterior ahora se leen los datos que se haban
guardado en "c:\\yamil.txt".
26de48

yacerque@gmail.com
Ejemplo 12: Uso d ela funcin fread.

#include <stdio.h>
#include <conio.h>
struct
{
char nombre[20];
char apellido[20];
char telefono[15];
} registro;
int main()
{ FILE *archivo;
archivo = fopen( "c:\\yamil.txt", "r" );
while (!feof(archivo))
{ if (fread( &registro, sizeof(registro), 1, archivo ))
{ printf( "Nombre: %s\n", registro.nombre );
printf( "Apellido: %s\n", registro.apellido);
printf( "Telfono: %s\n", registro.telefono);
}
}
fclose( archivo );
getch();
}
Se Abre el archivo c:\\yamil.txt en modo lectura. Con el bucle while nos

aseguramos que recorremos el archivo hasta el final (y que no nos
pasamos).
La funcin fread lee un registro (numero=1) del tamao de la estructura
registro. Si realmente ha conseguido leer un registro la funcin devolver un
1, en cuyo caso la condicin del 'if' ser verdadera y se imprimir el registro
en la pantalla. En caso de que no queden ms registros en el archivo, fread
devolver 0 y no se mostrar nada en la pantalla.
Estructuras guardadas en archivos binarios:

Ejemplo 13: Almacenamiento de estructuras en archivos de binarios.
Los datos son colocados desde el momento de la edicin del programa en la
estructura.
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define N 2
/* Dimensin de los vectores (nmero de productos) */
/* Declaracin de una estructura para los productos */
typedef struct
27de48

yacerque@gmail.com
{ char nombre[12];
int estatura;
} PROD;
void main(void)
{ PROD prod[N];
/* Vector de productos en el almacn */
int i;
/* contador para los bucles*/
FILE *f; /* Descriptor del archivo de texto */ /*** Inicializo del vector ***/
strcpy(prod[0].nombre,"Yamil Cerquera");
prod[0].estatura=179;
strcpy(prod[1].nombre,"Armando Rojas");
prod[1].estatura=180;
/*** Se crea el archivo ***/
f=fopen("c:\\yamil.txt","wb");
if (f==NULL)
{ printf("Error al crear el archivo datos.dat\n");
exit(1); }
for (i=0; i<N; i++) fwrite(&prod[i],sizeof(prod[i]),1,f);
fclose(f);
}
wb: abre el archivo para escritura en modo binario.

Resultado: no se puede ver pero ocupa 28 caracteres ya que cada estructura
ocupa 14 bytes hablando en programacin 16 bits (el tipo int ocupa dos (2)
bytes)
Ejemplo 14: Almacenamiento de estructuras en archivos de binarios.
Los datos son ledos desde el teclado y pasados directamente al archivo
binario.
#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
typedef char T_Cadena30[30];
typedef struct
{ T_Cadena30 nombre;
int edad; } T_Ficha;
void main(void)
{ FILE *punt; T_Ficha ficha; T_Ficha ficha2;
punt=fopen("c:\\yamil.txt","wb");
if (punt==NULL) { printf("\n Error al abrir el archivo "); exit(1); }
printf("Introduzca el nombre de la persona:\n"); gets(ficha.nombre);
printf("Introduzca la edad de la persona:\n"); scanf("%d",&ficha.edad);
fwrite(&ficha, sizeof(T_Ficha), 1, punt);
if (fclose(punt) != 0) { printf(Error al cerrar el archivo ); exit(1); }
punt=fopen("c::\\yamil.txt","rb");
if (punt==NULL) { printf("\n Error al abrir el archivo "); exit(1); }
28de48

yacerque@gmail.com
fread(&ficha2, sizeof(T_Ficha), 1 , punt);
printf("NOMBRE: "); puts(ficha2.nombre);
printf("EDAD: ");
printf("%d",ficha2.edad);
if (fclose(punt) != 0) { printf(Error al cerrar el archivo ); exit(1); }
punt=fopen("c:\\yamil.txt ","rb");
if (punt==NULL)
{ printf("\n Error abriendo el archivo "); exit(1); }
for (cont=0;cont<N;cont++)
{ fread(&lista[cont], sizeof(T_Ficha),1,punt);
printf("NOMBRE: "); puts(lista[cont].nombre);
printf("EDAD: ");
printf("%d\n",lista[cont].edad);
}
if (fclose(punt) != 0 ) { printf(Error al cerrar el archivo); exit(1); }
getch();
}
Ejemplo 15: Uso de fflush, fwrite

#include <stdio.h>
#include <stdlib.h>
#define N 5
typedef struct
{ char nombre[30];
int edad;
} T_Ficha;
void main(void)
{ FILE *punt;
T_Ficha ficha;
T_Ficha lista[N];
int cont;
punt=fopen(c:\\yamil.txt","wb");
if (punt==NULL) { printf("\n Error abriendo el archivo "); exit(1); }
{ fflush(stdin);
printf("Introduzca la edad de la persona:\n");scanf("%d",&ficha.edad);
}
}
Ejemplo 16: Uso de la funcin fread

#include <stdio.h>
#include <stdlib.h>
#define N 5
typedef struct
{ char nombre[30];
int edad;
} T_Ficha;
29de48

yacerque@gmail.com
void main(void)
{ FILE *punt;
T_Ficha ficha;
T_Ficha lista[N];
int cont;
punt=fopen(c:\\yamil.txt","wb");
{ fflush(stdin);
printf("Introduzca la edad de la persona:\n"); scanf("%d",&ficha.edad);
}
If (fclose(punt) != 0 ) { printf(Error al cerrar el archivo); exit(1); }
punt=fopen("c:\\yamil.txt ","rb");
fread(lista, sizeof(T_Ficha),N ,punt);
for (cont = 0; cont < N; cont++)
{ printf("NOMBRE: "); puts(lista[cont].nombre);
printf("EDAD: ");
}
if (fclose(punt) != 0 ) { printf(Error al cerrar el archivo); exit(1); }
}
Acceso directo a registros en archivos binarios

Funcin fseek
Hay veces en que se necesita acceder una y otra vez al fichero para leer sus
datos, modificar parte de ellos, por el medio. Imagine, por ejemplo, que se
tiene guardado en un archivo una agenda de telfonos, con los amigos. A
veces se quiere consultar uno que est en medio del archivo, o cambiar su
nmero de telfono, o borrarlo como amigo porque ya n o est o no se desea
tener.
C ofrece esta posibilidad. La funcin fseek() permite desplazarse
rpidamente, sin necesidad de ir leyendo registro a registro, hasta una
posicin concreta de un fichero. Esto es lo que se conoce como acceso
aleatorio a un fichero.
La funcin fseek permite situar en la posicin que se desee de un archivo
abierto. Cuando se lee un archivo hay un 'puntero o cursor' que indica en
qu lugar del archivo se encuentra. Cada vez que se lea datos del archivo,
30de48

yacerque@gmail.com
este puntero se desplaza un registro adelante. Con la funcin fseek se

puede situar este puntero en el lugar que se desee.
Prototipo: int fseek(FILE *archivo, long posicin, int origen);
Valor de retorno:
xito: devuelve 0 (el puntero

satisfactoriamente)
Error: devuelve un valor distinto de 0
del
archivo
se
desplaz
Los parmetros de entrada son: un puntero a una estructura FILE del archivo
en el que se quiere cambiar el cursor de lectura/escritura, el valor del
desplazamiento y el punto de origen desde el que se calcular el
desplazamiento.
archivo: Puntero al buffer del archivo con el que se esta trabajando.
posicin: Desplazamiento en bytes a partir de lo que indique origen.
Son las posiciones (o bytes) que se quiere desplazar el puntero.
Este desplazamiento puede ser de tres tipos dependiendo del valor
de modo:
origen: Especifica donde comienza la bsqueda. El parmetro origen
puede tener tres posibles valores:
SEEK_CUR: El desplazamiento se cuenta desde la posicin
actual del cursor.
SEEK_END: El desplazamiento se cuenta desde el final del
fichero.
SEEK_SET: el desplazamiento se cuenta desde el principio del
fichero. El primer byte del fichero tiene un desplazamiento
cero.
Estas tres constantes estn definidas en el fichero <stdio.h>. Como
curiosidad se indican a continuacin sus definiciones:
#define SEEK_SET
#define SEEK_CUR
#define SEEK_END
0
1
2
Nota: es posible que los valores cambien de un compilador a otro.

Ejemplo 17: Diferentes usos de la Constante Seek
31de48

yacerque@gmail.com
fseek(fp,1,SEEK_SET);
fseek(fp,10*sizeof(producto[0]),SEEK_SET);
fseek(fp,2*sizeof(producto[0]),SEEK_CUR);
/* Va a la primera posicin del archivo */

/* Va al dcimo producto del archivo*/
/* Se salta dos mas*/
Ejemplo 18: Uso de la funcin fseek.

#include <stdio.h>
int main()
{ FILE *archivo;
int pos_cursor;
int valor_devuelto;
archivo = fopen( "origen.txt", "r" ); /* Se supone que no hay error al abrir el archivo*/
printf( "Qu posicin desea leer? " ); fflush(stdout);
scanf( "%d", & pos_cursor);
valor_devuelto = fseek( archivo, pos_cursor, SEEK_SET );
if (!valor_devuelto)
printf( "En la posicin %d est la letra %c.\n", pos_cursor, getc(archivo);
else
printf( "Problemas posicionando el cursor.\n" );
fclose( archivo );
}
Funcin ftell
Esta funcin es complementaria a fseek, devuelve la posicin actual del
cursor dentro del archivo.
Su formato es el siguiente:
long int ftell(FILE *parchivo);
El valor que devuelve ftell puede ser usado por fseek para volver a la
posicin actual y estos valores corresponden a la posicin donde se
encuentre o -1 en caso de algn error.
El parmetro de entrada FILE *parchivo es un puntero a una estructura
FILE del fichero del que queremos leer la posicin del cursor de
lectura/escritura.
Ejemplo 19: Uso de las funciones fseek() y ftell()
32de48

yacerque@gmail.com
#include <stdio.h>
#include <string.h>
int main()
{ char nombre[11] = "yamil.dat", mensaje[81]="";
FILE *fichero;
long int comienzo, final;
fichero = fopen( nombre, "r" );
printf( "Fichero: %s -> ", nombre );
if( fichero )
printf( "existe (ABIERTO)\n" );
else
{ printf( "Error (NO ABIERTO)\n" );
return 1;
}
if( (comienzo=ftell( fichero )) < 0 ) printf( "ERROR: ftell no ha funcionado \n" );
else printf( "Posicin del fichero: %d \n \n", comienzo );
fseek( fichero, 0L, SEEK_END );
final = ftell( fichero );
fseek( fichero, 0L, SEEK_SET );
fgets( mensaje, 80, fichero );
printf( "Tamao del fichero \"%s\": %d bytes \n", nombre, final-comienzo+1 );
printf( "Mensaje del fichero: \n %s \n", mensaje );
printf( "Tamao del mensaje (usando strlen): %d \n", strlen(mensaje) );
if( !fclose(fichero) )
printf( "Fichero cerrado\n" );
else
{ printf( "Error: fichero NO CERRADO\n" );
return 1;
}
return 0;
}
Ejemplo 20: Archivos binarios usando la funcin fseek()

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef struct
{ char nombre[30];
int edad; } T_Ficha;
typedef T_Ficha T_Lista[10];
void introducir_datos(T_Lista lista);
void escribe_datos(T_Lista lista);
void guardar_archivo(T_Lista lista);
void cargar_archivo(T_Lista lista);
void modificar(void);
void main(void)
{ T_Lista lista,lista2;
introducir_datos(lista);
guardar_archivo(lista);
33de48

yacerque@gmail.com
modificar();
cargar_archivo(lista2);
escribe_datos(lista2);
}
void introducir_datos(T_Lista lista)
{ int cont;
printf("Introduzca los nombres y edades de 5 personas: \n");
for (cont=0;cont<5;cont++)
{ fflush(stdin);
printf("Introduzca nombre:\n"); gets(lista[cont].nombre);
printf("Introduzca edad:\n");
scanf("%d",&lista[cont].edad);
}
}
void escribe_datos(T_Lista lista)
{ int cont;
printf("\n:::::Los datos del archivo ledo son:\n");
for (cont=0;cont<5;cont++)
{ printf("NOMBRE: "); puts(lista[cont].nombre);
printf("EDAD: ");
}
}
void guardar_archivo(T_Lista lista)
{ FILE *punt; int cont;
printf("\nGUARDANDO ARCHIVO....\n");
punt=fopen("c:\\yamil.txt","wb");
if (punt==NULL)
{ printf("\nERROR"); exit(1); }
for(cont=0;cont<5;cont++)
{ fwrite(&lista[cont],sizeof(T_Ficha),1,punt); }
/* Otra opcin en vez del bucle anterior
fwrite(lista,sizeof(T_Ficha),5,punt); */
{ printf(Error al cerrar el archivo); exit(1); }
printf("\n:::::ARCHIVO GUARDADO:::::\n");
}
void cargar_archivo(T_Lista lista)
{ FILE *punt;
int cont=0;
printf("\nLEYENDO ARCHIVO.................\n");
punt=fopen("c:\\yamil.txt","rb");
if (punt==NULL)
{ printf("\n Error al abrir el archivo");
exit(1);
}
while ( fread(&lista[cont],sizeof(T_Ficha),1,punt)) == 1)
{ cont++; }
34de48

yacerque@gmail.com
{
printf(Error cerrando el archivo );

exit(1);
}
printf("\n:::::ARCHIVO LEIDO:::::\n");
void modificar(void)
{ FILE *punt; T_Ficha registro;
int cont=0;
T_Cadena30 cadena;
fflush(stdin);
printf("\n Introduzca nombre a buscar:\n");
gets(cadena);
printf("\n Leyendo File y Buscando Name solicitado .....\n");
punt=fopen("c:\yamil.txt","rb+");
if (punt==NULL)
{ printf("\nERROR"); exit(1);
}
do
{ fread(&registro,sizeof(T_Ficha),1,punt);
cont++; }
while ((strcmp(registro.nombre,cadena)!=0)&&(cont<5));
if (strcmp(registro.nombre,cadena)==0)
{ printf("\n...INDIVIDUO ENCONTRADO.....\n");
printf("\n...DATOS ACTUALES:\n");
printf("NOMBRE: %s\n",registro.nombre);
printf("EDAD: %d\n",registro.edad);
printf("\n:::::INTRODUZCA NUEVOS DATOS::::::\n");
fflush(stdin);
printf("Introduzca el nombre de la persona:\n");
gets(registro.nombre);
printf("Introduzca la edad de la persona:\n");
scanf("%d",&registro.edad);
printf("\n MODIFICANDO LOS DATOS EN EL ARCHIVO...\n");
fseek(punt,(cont-1)*sizeof(T_Ficha),SEEK_SET);
fwrite(&registro,sizeof(T_Ficha),1,punt);
printf("\n..DATOS MODIFICADOS EN EL ARCHIVO....\n");
}
else
printf("\n:El nombre solicitado no se encuentra en el file:\n");
{ printf("\n:::::ARCHIVO GUARDADO:::::\n"); exit(1); }
}
Ejemplo 21: Archivos

Page 67 El lenguaje de programacin C++ U austral Chile.
#include<iostream.h>
#include<string.h>
#include<stdio.h>
35de48

yacerque@gmail.com
#include<ctype.h>
#include<process.h>
#include<stdlib.h>
#define maxi 100
#include <vcl.h>
#include <conio.h>
#include <s.cpp> // debe quedar guardada en la librera
#pragma hdrstop
#pragma argsused
struct alumno
{ char nombre[30];
char direccion[50];
char ciudad[20];
int cod_area;
unsigned long int fono;
} datos[maxi];
void ini_lista(), ingresar(), mostrar(), guardar(), cargar();
char menu();
int main()
{ char elige;
ini_lista();
for(;;)
{ elige=menu();
switch(elige)
{ case 'i':ingresar();break;
case 'm':mostrar();break;
case 'g':guardar();break;
case 'c':cargar();break;
case 's':exit(1); }
}
getch();
return 0;
}
/* inicializa arreglo */
void ini_lista()
{ for(int i=0; i<maxi ; i++)
*datos[i].nombre='\0';
}
/* men de seleccin */
char menu()
{ //char s;
// o se puede usar
char s[80];
do
{ clrscr();
cout<<" (I) Ingresar \n";
cout<<" (M) Mostrar \n";
cout<<" (C) Cargar \n";
36de48

yacerque@gmail.com
cout<<" (G) Guardar \n";
cout<<" (S) Salir \n";
//s=getch();
// o se puede usar tambin gets(s) conf con enter;
gets(s);
} while(!strrchr("imcgs",tolower(*s)));
return char(tolower(*s));
}
/* Ingreso de nombres a la lista */
void ingresar()
{ int i;
for(i=0; i<maxi; i++)
if(!*datos[i].nombre) break;
if(i==maxi)
{ cout<<"La lista esta llena \n";
return; }
cout << " nombre : ";gets(datos[i].nombre);
cout << " direccion : ";gets(datos[i].direccion);
cout << " ciudad : ";gets(datos[i].ciudad);
cout << " cdigo de rea : ";cin >>datos[i].cod_area;
cout << " telfono : ";cin >>datos[i].fono;
}
/* Mostrar la lista */
void mostrar()
{ for(int i=0; i<maxi ; i++)
{ if(*datos[i].nombre)
{ cout<<'\n'<<datos[i].nombre;
cout<<'\n'<<datos[i].direccion;
cout<<'\n'<<datos[i].ciudad;
cout<<'\n'<<datos[i].cod_area;
cout<<"-"<<datos[i].fono;
cout<<'\n';
}
}
getch();
}
/* Guardar la lista */
void guardar()
{ FILE *fp;
fp=fopen("c://prueba//datos.txt","a");
if(fp==NULL)
{ cout<<"no se puede abrir el archivo \n";
return; }
for(int i=0; i<maxi; i++)
if(*datos[i].nombre)
if(fwrite(&datos[i],sizeof(struct alumno),1,fp)!=1)
cout<<" Error de escritura en el archivo \n";
fclose(fp);
37de48

yacerque@gmail.com
}
/* Cargar el archivo */
void cargar()
{ FILE *fp;
fp=fopen("c://prueba//datos.txt","r");
if(fp==NULL)
{ cout << " No se puede abrir el archivo \n"; return; }
ini_lista();
for(int i=0; i<maxi; i++)
if(fread(&datos[i],sizeof(struct alumno),1,fp)!=1)
{ if(feof(fp))
{ fclose(fp); return; };
cout<<"Error de lectura en el archivo \n";
}
}
Archivos con Jerarqua de clases

Para manipular los archivos, C++ nos presenta una jerarqua de clases
especialmente diseadas para ello. Donde nos concentraremos en dos de
ellas: ifstream para manipular archivos de entrada de datos y ofstream para
manipular archivos de salida de datos.
Existen algunas operaciones bsicas que se realizan sobre los archivos, estas
son:
Creacin del objeto.

Apertura del archivo.
Manipulacin del archivo.
Cierre del archivo.
Creacin del objeto.

Para la creacin del objeto debemos declarar una variable cuyo tipo es
algunas de las clases nombradas. Por ejemplo, si queremos un trabajar con
un archivo de entrada de datos, declaramos:
ifstream ArchivoEnt;
Si el archivo fuera de salida de datos, declaramos:
ofstream ArchivoSal;
38de48

yacerque@gmail.com
Apertura del archivo.

La apertura de un archivo establece la conexin entre el nombre lgico y el
nombre fsico de nuestro archivo, abre el archivo y lo prepara para su
manipulacin.
Esto se puede realizar de dos maneras, la primera es a travs del mtodo
open:
void open(const char *nombre_archivo, openmode modo);
Este mtodo puede recibir dos parmetros, el primero es una cadena de
caracteres que representa el nombre fsico del archivo que ser abierto, y
opcionalmente puede recibir un segundo parmetro que representa al modo
que se abrir.
Puede ser alguna de las siguientes opciones:
ios::in
ios::out
ios::ate
ios::app
ios::nocreate
ios::noreplace
ios::trunc
ios::binary
Abre el archivo para lectura

Abre el archivo para escritura
Abre un archivo existente y se posiciona al final
Abre un archivo de salida para agregar al final
Abre un archivo slo si ya existe.
Abre un archivo slo si no existe.
Abre un archivo, si ya existe borra todo su contenido
Abre un archivo en modo binario. Por defecto es modo
texto.
Estas opciones se pueden combinar utilizando el operador or |, pero no todas

las combinaciones son posibles. Un ejemplo seria:
ArchivoSal.open(datos.txt, ios::out | ios::app);
Como dijimos anteriormente, el modo de apertura es un parmetro opcional
del mtodo, dado que de acuerdo a la clase hayamos creado el objeto, posee
un modo de apertura por defecto. Estos son:
Clase
Modo por defecto
ofstream
ifstream
ios::out | ios::trunc
ios::in
39de48

yacerque@gmail.com
fstream
ios::in | ios::out
La segunda manera de abrir un archivo, es combinndola con la creacin del

objeto.
Esto se puede realizar gracias a que el constructor de estas clases puede
recibir el nombre del archivo fsico como parmetro y realiza internamente la
llamada al mtodo open.
ifstream ArchivoEnt(datos.txt);
Cierre del archivo.
Como se abra dado cuenta nos salteamos, el apartado correspondiente a la
manipulacin del archivo. Esto lo hacemos dado que es la parte ms
compleja, y preferimos dejarlo para el final.
Al terminar la manipulacin del archivo, se debe cerrar el vnculo que hemos
creado con nuestro archivo fsico, para liberarlo y permitir que otros
programas (o procesos) puedan usarlo. A dems se realizan otras acciones
internas como liberar la memoria de un buffer creado, terminar de escribir
sobre el archivo (dado que esta accin se realiza de a bloques), etc.
Esta accin se realiza mediante la llamada al mtodo close().
ArchivoEnt.close();
Una vez cerrado el archivo, este objeto esta disponible para abrir
nuevamente otro archivo o ser destruido.
El cierre del archivo tambin se realiza de forma automtica cuando el objeto
es destruido. Esto se debe a que el destructor de la clase verifica si existe un
archivo abierto, y si es as, llama al mtodo close().
Manipulacin del archivo.
Con este trmino nos referimos, a la accin de leer o escribir sobre un
archivo. A pesar de que estas acciones son simples, se pueden armar
estructuras complejas de acuerdo a la necesidad de cada problema.
40de48

yacerque@gmail.com
Estas acciones, se pueden realizar mediante operadores o llamadas a

mtodos.
Operadores de lectura / escritura
Existen dos operadores:
1. Operador de insercin: <<
Este operador permite insertar o escribir dentro del archivo un texto. El texto
puede ser una cadena de caracteres o no, gracias a que estas clases saben
realizar la conversin de tipo de forma automtica. Vamos a ver algunos
ejemplos:
Cdigo ejemplo
Archivo salida
En este primer ejemplo vemos como se inserta una simple cadena de

caracteres a un archivo de texto tipo ofstream llamado ArchivoSal
ArchivoSal << alumno;
alumno
En el siguiente ejemplo, se puede tener el mismo efecto insertando el

contenido de la variable Texto.
string Texto = Hola
ArchivoSal << Texto;
Hola
En este ejemplo, vemos que se pueden realizar inserciones sucesivas de

dentro de una misma fila, con la separacin de un carcter de espacio que se
realiza de forma automtica. Al final de cada rengln agregamos endl para
insertar un caracter de fin de lnea, para movernos a la siguiente lnea.
string Texto = Hola;
ArchivoSal << Texto << 1 << endl;
ArchivoSal << Texto << 2 << endl;
Hola1
Hola2
Ahora vea que se puede tambin realizar la insercin del contenido una
variable entera, cuyo contenido se convierte de forma automtica en una
cadena de caracteres. Adems se puede observar otra forma de insertar el
caracter de fin de lnea agregando \n
41de48

yacerque@gmail.com
int num = 1;
ArchivoSal << num << Hola\n;
Num++;
ArchivoSal << num << Hola\n;
1Hola
2 Hola
Por ltimo se muestra un ejemplo completo, con muchas combinaciones de

guardado, para que analicen la salida.
string Texto1 = "Hola";
string Texto2 = "Mundo";
int num = 1;
Archi << Texto1 << Texto2 << endl;
Archi << Texto1 << " " << Texto2 << endl;
Archi << num << num++ << endl;
Archi << num << " " << num++ << endl;
Archi << num++ << " " << num << endl;
Archi << Texto1 << num << "\n";
Archi << num++ << Texto2 << endl;
HolaMundo
Hola Mundo
21
32
33
Hola4
4Mundo
2. Operador de extraccin: >>

Este operador permite extraer del contenido de archivo, un texto. Este
operador extrae todo el contenido de la cadena y se lo asigna a la variable
hasta que encuentre un caracter de espacio o de fin de lnea. Similar al
anterior, el texto puede ser una cadena de caracteres o no, gracias a que
estas clases saben realizar la conversin de tipo de forma automtica, la
conversin se realizar de acuerdo al tipo de dato de la variable que
definamos. Vamos a ver algunos ejemplos:
Cdigo ejemplo
Archivo entrada
variables
En este primer ejemplo vemos como extrae una simple cadena de caracteres
de un archivo de texto tipo ifstream llamado ArchivoEnt.
string Texto;
ArchivoEnt >> Texto;
alumno
Texto = alumno
En este par de ejemplos, se ve como el mismo cdigo permite leer cadenas

de caracteres sucesivas independientes que estn separadas por un caracter
de espacio o de fin de lnea.
42de48

yacerque@gmail.com
string Texto1, Texto2;

ArchivoEnt >> Texto1 >> Texto2;
string Texto1, Texto2;
ArchivoEnt >> Texto1 >> Texto2;
alumno1 alumno2
Texto1 = alumno1
Texto2 = alumno2
alumno1
alumno2
Texto1 = alumno1
Texto2 = alumno2
Ahora se observa que tambin se puede extraer la informacin independiente

de que este sea un entero. Dado que la segunda extraccin se hace sobre
una variable del tipo int, la conversin se realiza automticamente. Hay que
tener cuidado que el dato a leer sea un entero, dado que C++ realiza la
lectura igualmente pudindose obtener informacin errnea.
int num;
string Texto;
ArchivoEnt >> Texto >> num;
alumno 1
Texto = alumno
num = 1
Mtodos de lectura / escritura

Como dijimos anteriormente, la lectura y escritura de datos tambin se
puede realizar mediante llamadas a mtodos de la clase. Veamos cuales son:
get() y getline():
Estos mtodos permiten realizar la lectura de toda una lnea, hasta que
encuentra un caracter de terminacin.
Reciben tres parmetros. El primero es un puntero a un vector de caracteres
(buffer), el segundo el tamao del vector, y el tercero (opcional) el caracter
de terminacin. Por defecto este caracter es el \n, llamado caracter de fin
de lnea.
Si el primer caracter de la lnea es el carcter de terminacin, devuelven un
vector de longitud cero. Pero su gran diferencia radica, en que el mtodo
get() se detiene, y una segunda llamada al mtodo devuelve el mismo
resultado, hasta que se cambie el caracter de terminacin. En cambio, una
segunda llamada al mtodo getline() devuelve la siguiente lnea, por lo que
normalmente se utiliza este mtodo.
Otra diferencia radica en que el mtodo get() puede ser llamado sin ningn
parmetro. En este caso devuelve el caracter siguiente.
43de48

yacerque@gmail.com
Para aclarar un poco el tema, se notan algunos ejemplos:

Cdigo ejemplo
Archivo entrada
Archivo salida
En este primer ejemplo vemos una simple lectura de una cadena de

caracteres de un archivo llamado entrada.txt y su escritura en el archivo
salida.txt.
char buff[10];
ifstream ArchiEnt("entrada.txt");
ofstream ArchiSal("salida.txt");
ArchiEnt.getline(buff, 10);
ArchiSal << buff << endl;
alumno
alumno
Ahora la diferencia de leer el texto de una lnea que posee ms caracteres

que los que pedimos leer. Veremos la diferencia de la implementacin con la
funcin get() y con getline().
char buff[10];
Alumno que no piensa

no aprueba
char buff[10];
ArchiEnt.get(buff, 10);
ArchiEnt.get(buff, 10);

no aprueba
Alumno gu
Alumno gu
Alumno qu
e no pien
Ahora vemos que pasa cuando se tiene una lnea vaca. Aclaramos que en la
salida del segundo ejemplo, hay dos lneas vacas.
char buff[10];
Alumno
no aprueba
Alumno
44de48

yacerque@gmail.com
for (int i=1; i<=3; i++)

{ ArchiEnt.get(buff, 10);
ArchiSal << buff << endl; }
no aprueb
char buff[10];
for (int i=1; i<=3; i++)
{ ArchiEnt.get(buff, 10);
ArchiSal << buff << endl;}
Alumno
no aprueba
Alumno
Ahora se ver como se hace si quiere leer una lnea y asignrsela

directamente a una variable del tipo string, no es tan simple como parece.
Para resolver el problema se hace uso de tres funciones de la clase string. La
funcin begin() que devuelve un puntero al primer caracter de la cadena.
Para especificar la cantidad de caracteres a leer se puode colocar
simplemente un nmero que lo indica, si se sabe que las lneas del archivo
no superan ese valor, o usar la funcin max_size() que devuelve la mxima
cantidad de caracteres que soporta la clase string; a este valor hay que
dividirlo por 2, dado que es el doble que el mximo valor del entero (int) que
pide como parmetro la funcin. Por ltimo, hay que utilizar la funcin
c_str() para que devuelva el valor de la cadena contenida.
string Texto;
ArchiEnt.getline(Texto.begin(),
Texto.max_size()/2);
ArchiSal << Texto.c_str() << endl;

Hay que destacar que el mtodo getline, escribe directamente en una porcin
de memoria del string, que contiene la cadena c_string sin modificar ninguna
de las propiedades de la clase string. Es por ello, que al querer escribir en un
archivo se debe especificar que se desea escribir el contenido c_str() del
string, dado que si quiero escribir directamente el string, como no se
modificaron sus propiedades, la longitud de la cadena es cero, y por lo tanto
virtualmente la cadena esta vaca.
Una forma de forzar a que se actualicen las propiedades del string, es
realizar una asignacin de su propio contenido:
string Texto;
45de48

yacerque@gmail.com
ArchiEnt.getline(Texto.begin(),
Texto.max_size()/2);
Texto = Texto.c_str();
ArchiSal << Texto << endl;
La verdad es que parece un poco complejo, y poco recomendable leer una

simple lnea de longitud indeterminada con el mtodo anterior.
Por suerte, existe una funcin llamada getline() que realiza este
procedimiento de forma ms simple. Remarcamos que es una funcin y no
un mtodo como el que vimos antes. Esta funcin recibe un primer
parmetro que es un ifstring, el segundo es un string, y opcionalmente
puede recibir un tercer parmetro que es el carcter de terminacin.
Esta funcin esta especialmente diseada para leer string, por lo que no es
necesario especificar el largo de la cadena.
string Texto;
getline(ArchiEnt, Texto);
ArchiSal << Texto << endl;

Mtodos especiales
eof()
Es uno de los mtodos ms importantes. Devuelve true si se lleg al final de
archivo. Encontr el carcter EOF (End Of File).
is_open()
Este mtodo devuelve true si se abri correctamente el archivo.
good()
Este mtodo devuelve true si no ocurri ningn error.
bad()
46de48

yacerque@gmail.com
Este mtodo devuelve true si ocurri algn error con el buffer.

fail()
Este mtodo devuelve true si ocurri algn error que no afecte al buffer.
Ejemplo 22
Implementar una funcin que lea un archivo de texto llamado Datos.txt,
que contiene un nmero indeterminado de nmeros ordenados en columna,
y devuelva su promedio.
Para resolverlo debemos realizar un ciclo que lea lnea por lnea cada uno de
los nmeros, los vaya sumando y contando la cantidad de datos ledos, y por
ltimo calcule e informe el resultado.
float PromedioDatos()
{ float x, suma = 0;
int cont = 0;
ifstream Archivo(Datos.txt);
while (!Archivo.eof())
{ Archivo >> x;
suma += x;
cont++;
}
return suma/cont;
}
Ejemplo 23
Implementar una funcin que lea un archivo de texto llamado Lineas.txt,
que contiene un nmero indeterminado de renglones, que contiene frases, y
devuelva la cantidad lneas que contienen la palabra casa.
Para resolverlo debemos realizar un ciclo que lea lnea por lnea cada uno de
los renglones, busque la palabra casa y los cuente, y por ltimo informe el
resultado.
float CantidadCasas()
{ int cont = 0;
string s;
AnsiString Linea;
ifstream Archivo(Lineas.txt);
while (getline(Archivo, s))
{ Linea = s.c_str();
if (Linea.Pos(casa) cont++;
47de48

yacerque@gmail.com
}
return cont;
EJEMPLO 18:
#include <vcl.h>
#pragma hdrstop
#include <condefs.h>
#include <fstream.h>
#include <iostream.h>
#include <conio.h>
#pragma argsused
int main(int argc, char* argv[])
{ char b[80];
ifstream infile("yamil.cpp");
//infile.open("yamil.cpp");
if (!infile) return 0;
while (!infile.eof())
{ infile.getline(b,sizeof(b));
cout <<b<<endl;
}
infile.close();
cout <<"presione una tecla" <<endl;
getch();
return 0;
}
48de48

Archivos - Fundamentos

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Archivos - Fundamentos

Transféré par

Droits d'auteur :

Formats disponibles

Ing Yamil Armando Cerquera Rojas

Ing Yamil Armando Cerquera Rojas

Apertura del archivo...............................................................................31

Ing Yamil Armando Cerquera Rojas

Ing Yamil Armando Cerquera Rojas

Ing Yamil Armando Cerquera Rojas

Un archivo es un dispositivo de entrada-salida cuyo fin ltimo es guardar

Apertura de archivos: fopen()

Es importante indicar que los archivos archivos FILES no son nicamente

Path: indica la ruta para encontrar el archivo incluyendo la unidad de

Ing Yamil Armando Cerquera Rojas

En el caso del ejemplo anterior, el path sera C:\programacion\, para

Clasificacin de los archivos

Ing Yamil Armando Cerquera Rojas

Longitud variable: en realidad, en este tipo de archivos no tiene

Es posible crear archivos combinando cada una de estas categoras, por

Diferencias con el manejo de pantalla y teclado:

Ing Yamil Armando Cerquera Rojas

FILE es un tipo especial de estructura que establece el rea del

Ing Yamil Armando Cerquera Rojas

Apertura de un archivo: fopen()

nombre_completo_archivo (cadena de caracteres): es el nombre del

Ing Yamil Armando Cerquera Rojas

Incluyendo el camino completo y la unidad en caso de que fuera

Apertura de un archivo: Modo

Abre un archivo existente para lectura.

t: modo texto. Normalmente es el modo por defecto. Se suele omitir.

En ciertos sistemas operativos no existe esta distincin, y todos los archivos

rb+ - Abre el archivo en modo binario para lectura y escritura.

En resumen en el lenguaje de programacin C, los archivos admiten seis

r: slo lectura. El archivo debe existir.

Ing Yamil Armando Cerquera Rojas

w+: lectura y escritura, se crea un archivo nuevo o se sobrescribe si ya

Comprobar si un archivo est abierto

Cierre de un archivo: fclose()

Ing Yamil Armando Cerquera Rojas

parmetro es un puntero a la estructura FILE del archivo que se quiere

Operaciones bsicas con archivos

Declaracin de un puntero a archivo

Ing Yamil Armando Cerquera Rojas

Ing Yamil Armando Cerquera Rojas

Las funciones fprintf() y fscanf():

Ing Yamil Armando Cerquera Rojas

/* Nmero de datos a grabar*/

Ing Yamil Armando Cerquera Rojas

Para el anterior ejemplo, en caso de no existir el archivo yamil.txt sobre la

Comprobar fin de archivo feof

con la funcin feof()

En el ejemplo ha usado la funcin feof. Esta funcin es de la forma:

Esta funcin comprueba si se ha llegado al final del archivo en cuyo caso

Ing Yamil Armando Cerquera Rojas

La segunda forma consiste en comprobar si el carcter ledo es el de fin de

Cuando se trabaja con archivos de texto no hay ningn problema, pero si se

Si el archivo yamil.txt contiene:

Ing Yamil Armando Cerquera Rojas

Las funciones fgets(), fputs(), getc() fgetc(), putc()

Ejemplo 3: Uso de la funcin putc

Ing Yamil Armando Cerquera Rojas

Ejemplo 4: Uso de la funcin fgetc

Lectura de una cadena de caracteres con la funcin fgets:

Ing Yamil Armando Cerquera Rojas

todos estos casos, se escribe un carcter \0 en la cadena a continuacin

Escritura de una cadena de caracteres con la funcin fputs