PREGRADO SI MRZ19 - JUL19

INGENIERÍA MECATRÓNICA

FUNDAMENTOS DE PROGRAMACIÓN

NRC - 4091

FORO SOBRE ENTRADA Y SALIDA POR ARCHIVOS

Nombres:

Camacho Jibaja Carlos Fernando

Guachamín Taboada Pablo Andrés
Guerrero Merino Joe Alexander

Docente: Ing. Fausto Meneses

 2

Contenido

Marco teórico ......................................................................................................................................... 3

1. INTRODUCCIÓN ..................................................................................................................... 3
2. FLUJOS Y ARCHIVOS .................................................................................................................... 3
2.1. Flujos ................................................................................................................................... 3
2.2. Archivos ............................................................................................................................... 3
3. PUNTERO A ARCHIVO ......................................................................................................... 4
4. APERTURA DE UN ARCHIVO: fopen() ............................................................................... 4
5. CIERRE DE UN ARCHIVO: fclose() ..................................................................................... 4
6. ESCRITURA DE UN CARÁCTER: putc() ............................................................................ 5
7. LECTURA DE UN CARÁCTER: getc() ................................................................................. 6
8. FIN DE ARCHIVO: feof() ........................................................................................................ 7
9. INICIALIZAR EL INDICADOR DE POSICIÓN: rewind() ................................................ 8
10. ESCRITURA Y LECTURA DE CADENAS: fputs() y fgets() .......................................... 8
11. ELIMINACIÓN DE ARCHIVOS: remove() ...................................................................... 9
12. VACIAR EL CONTENIDO DE UN FLUJO: fflush() ....................................................... 9
13. DETERMINACIÓN DE ERRORES: ferror() ................................................................. 10
14. FLUJO DE DATOS BINARIOS ........................................................................................ 11
14.1. Lectura y escritura: fread() y fwrite() ............................................................................ 11
14.2. E/S de acceso directo: fseek() ....................................................................................... 11
14.3. Valor del indicador de posición del archivo: ftell()........................................................ 11
15. ESCRITURA Y LECTURA DE CUALQUIER TIPO DE DATOS: fprintf() y fscanf()
11
16. CONEXIÓN ENTRE LA CONSOLA Y LA E/S DE ARCHIVOS................................. 11
16.1. Utilización de las funciones de archivos para consola .................................................. 11
16.2. Utilización de las funciones de consola para archivos .................................................. 11
Programas en C ................................................................................................................................... 12
Conclusiones y Recomendaciones ...................................................................................................... 13
Conclusiones .................................................................................................................................... 13
Recomendaciones ............................................................................................................................ 13
Referencias ............................................................................................................................................ 14
 3

Marco teórico

1. INTRODUCCIÓN

Existen rutinas para abrir y cerrar archivos, y para leer y escribir en ellos utilizando datos formateados,
de manera similar a como se hace el formato de datos para entrada y salida en pantalla.

2. FLUJOS Y ARCHIVOS

2.1. Flujos
El manejo de archivos en un lenguaje como C emplea el uso deflujos (también llamados stream).Se
denominan flujos pues emplean una corriente de datos entre un origen y un destino. Entre el origen y el
destino existe una conexión llamada pipe es precisamente por este canal donde circulan los datos utiliza
un buffer para el acceso A los archivos. Este buffer está diseñado para acceder a una amplia gama de
dispositivos, de tal forma que trata cada dispositivo como una secuencia. Con las secuencias escomo se
simplifica el manejo de archivos en C.
2.2. Archivos
Un archivo es un conjunto de datos estructurados en una colección de entidades elementales o básicas
denominadas registros que son de igual tipo y constan a su vez de diferentes entidades de nivel más
bajos denominadas campos. Hay dos tipos de archivos, archivos de texto y archivos binarios.

Un archivo de texto es una secuencia de caracteres organizadas en líneas terminadas por un carácter de
nueva línea. 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 tamaño 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 traducción de caracteres. Además, el número de
bytes escritos (leídos) será el mismo que los encontrados en el dispositivo externo. Ejemplos de estos
archivos son Fotografías, imágenes, texto con formatos, archivos ejecutables (aplicaciones), etc. En c,
un archivo es un concepto lógico que puede aplicarse a muchas cosas desde archivos de disco hasta
terminales o una impresora. Se asocia una secuencia con un archivo especifico realizando una operación
de apertura. Una vez que el archivo está abierto, la información puede ser intercambiada entre este y el
programa.
 4

3. PUNTERO A ARCHIVO

El puntero a un archivo es el hilo común que unifica el sistema de E/S con buffer. Un puntero a un
archivo es un puntero a una información que define varias cosas sobre él, incluyendo el nombre, el
estado y la posición actual del archivo. En esencia identifica un archivo especifico y utiliza la secuencia
asociada para dirigir el funcionamiento de las funciones de E/S con buffer. Un puntero a un archivo es
una variable de tipo puntero al tipo FILE que se define en STDIO.H. Un programa necesita utilizar
punteros a archivos para leer o escribir en los mismos. Para obtener una variable de este tipo se utiliza
una secuencia como esta:

FILE *F;

4. APERTURA DE UN ARCHIVO: fopen()

La función fopen() abre una secuencia para que pueda ser utilizada y la asocia a un archivo. Su prototipo
es:

FILE *fopen(const char nombre_archivo, cost charmodo);

Donde nombre_archivo es un puntero a una cadena de caracteres que representan un nombre valido del
archivo y puede incluir una especificación del directorio. La cadena a la que apunta modo determina
como se abre el archivo. La siguiente tabla muestra los valores permitidos para modo.

La función fopen() devuelve un puntero a archivo. Un programa nunca debe alterar el

valor de ese puntero. Si se produce un error cuando se está intentando abrir un archivo,
fopen() devuelve un puntero nulo.
 5

Se puede abrir un archivo bien en modo texto o binario. En la mayoría de las

implementaciones, en modo texto, la secuencias de retorno de carro / salto de línea se
convierten a caracteres de salto de línea en lectura. En la escritura, ocurre lo contrario:
los caracteres de salto de línea se convierten en salto de línea. Estas conversiones no
ocurren en archivos binarios.

La macro NULL está definida en STDIO.H. Este método detecto cualquier error al abrir
un archivo: como por ejemplo disco lleno o protegido contra escritura antes de comenzar
a escribir en él.

Si se usa fopen() para abrir un archivo para escritura, entonces cualquier archivo
existente con el mismo nombre se borrará y se crea uno nuevo. Si no existe un archivo
con el mismo nombre, entonces se creará. Si se quiere añadir al final del archivo
entonces debe usar el modo a. Si se usa a y no existe el archivo, se devolverá un error.
La apertura de un archivo para las operaciones de lectura requiere que exista el archivo.
Si no existe, fopen() devolverá un error. Finalmente, sus se abre un archivo para las
operaciones de leer / escribir, la computadora no lo borrará si existe; sin embargo, si no
existe, la computadora lo creará.

5. CIERRE DE UN ARCHIVO: fclose()

La función fclose() cierra una secuencia que fue abierta mediante una llamada a fopen(). Escribe toda la
información que todavía se encuentre en el buffer en el disco y realiza un cierre formal del archivo a
nivel del sistema operativo. Un error en el cierre de una secuencia puede generar todo tipo de problemas,
incluyendo la pérdida de datos, destrucción de archivos y posibles errores intermitentes en el programa.

El prototipo de esta función es:

int fclose(FILE *F);

Donde F es el puntero al archivo devuelto por la llamada a fopen(). Si se devuelve un valor cero significa
que la operación de cierre ha tenido éxito. Generalmente, esta función solo falla cuando un disco se ha
retirado antes de tiempo o cuando no queda espacio libre en el mismo.
 6

6. ESCRITURA DE UN CARÁCTER: putc()

Si nos referimos a la escritura de archivos, si debemos escribir carácter por carácter, podemos utilizar las
funciones

putc()

fputc().

Ambas funciones no presentan diferencias pues retornan el carácter que fue escrito o EOF en caso de
no poder cumplir el objetivo.

putc(c, puntero_archivo);
fputc(c,puntero_archivo);

Donde c representa el carácter a escribir.

7. LECTURA DE UN CARÁCTER: getc()

La función getc() lee un caracterde un archivo abierto en modo lectura mediante la función
fopen().

El prototipo de la función getc() es:

int getc (FILE *pt);

donde: - pt, es el "puntero a archivo" devuelto por fopen().

La función getc() toma el caracter leído del archivo, o toma una marca EOF cuando se haya
alcanzado el final del archivo.

Entonces, la lectura de un archivo de texto puede realizarse hasta que se encuentre la marca de
fin de archivo, con las siguientes sentencias:

while ((car = getc (pt)) != EOF)

 7

putchar (car);

NOTAS:

- El estándar ANSI define dos funciones equivalentes que leen un caracter de un archivo: getc()
y fgetc(). Estas dos funciones idénticas solo existen para preservar la compatibilidad con
versiones antiguas de C. Por lo tanto, ambas funciones pueden utilizarse indistintamente.

- Debido a razones históricas getc() devuelve un entero, pero el byte más significativo es cero.

Las funciones fopen(), getc(), putc() y felose() constituyen el conjunto mínimo de rutinas de
tratamiento de archivos.

8. FIN DE ARCHIVO: feof()

La función feof() determina cuando se ha alcanzado el fin del archivo, al leer un archivo de
datos binario.

El prototipo de la función feof() es:

int feof (FILE *pt);

donde: - pt, es el "puntero a archivo" devuelto por fopen().

La función feof() devuelve verdadero si se ha alcanzado el final del archivo, en otro caso
devuelve 0.

Por ejemplo, para leer todo el archivo binario apuntado por pt, es decir, para leer el archivo
hasta que se encuentre el final del mismo y mostrar su contenido en la pantalla, se haría así:

while (!feof (pt))

puchar (getc (pt));

Se puede aplicar este método tanto a archivos binarios como a archivos de texto, hasta que se
encuentre el caracter EOF, que está definido en el archivo de cabecera "stdio.h" con el valor -
1. Esto sirve para trasladar bloques de datos sin importar el modo de almacenamiento.
 8

Cuando se abre un archivo para datos binarios, se puede leer un valor entero igual al de la marca
EOF. Esto podría hacer que en la lectura indique una condición de fin de archivo, aún cuando
el fin físico del mismo no se haya alcanzado.

Se usa el macro feof() (definido en stdio.h) para determinar si se ha encontrado el final de un

archivo. Si se encuentra el final de un archivo, devuelve un valor diferente de cero y cero en
caso contrario. Para invocarlo es necesario colocar el alias del archivo abierto como argumento.
Se utiliza mucho esta función en recorridos de tipo secuencial.

9. INICIALIZAR EL INDICADOR DE POSICIÓN: rewind()

La función rewind() posiciona el "indicador de posición del archivo" al principio del mismo.
Es decir, "rebobina" el archivo.

El prototipo de la función rewind() es:

void rewind (FILE *pt);

donde: -pt, es el "puntero a archivo" devuelto por fopen().

Se usa la función rewind para colocar el apuntador del archivo al principio de un archivo abierto.

10. ESCRITURA Y LECTURA DE CADENAS: fputs() y fgets()

Las funciones fputs() y fgets() escriben y leen cadenas de caracteres sobre archivos.

Los prototipos de las funciones fputs() y fgets() son:

int fputs (const char *cad, FILE *pt);

char *fgets (char *cad, int longitud, FILE *pt);

donde:

-pt, es el "puntero a archivo" devuelto por fopen().

- La función fputs() funciona como puts() pero escribe la cadena apuntada por cad en el flujo
especificado por pt. Si se produce un error devuelve EOF.
 9

- La función fgets() lee una cadena apuntada por cad del flujo especificado por pt, hasta que se
lee un caracter salto de línea o hasta que se hayan leído longitud-1 caracteres.

Si se lee un caracter de salto de línea, éste forma parte de la cadena leída (a diferencia de gets()).
La cadena resultante se termina en un carácter nulo.

La función fgets() devuelve un puntero a cad si se ha ejecutado correctamente, y un puntero

NULL si se produce un error.

11. ELIMINACIÓN DE ARCHIVOS: remove()

La función remove() borra el archivo especificado en su argumento.

El prototipo de la función remove() es:

int remove (char *nombre_archivo);

donde:

- nombre archivo, es el nombre del archivo en disco.

La función remove() devuelve cero si tiene éxito, y un valor distinto de cero si falla.

La función remove elimina definitivamente un archivo especificando su nombre. Es importante

destacar que esta función sólo puede aplicarse a archivos cerrados.

12. VACIAR EL CONTENIDO DE UN FLUJO: fflush()

La función fflush() vacía el contenido de un flujo especificado en el argumento, pero

previamente esta función escribe todos los datos almacenados en el buffer sobre el archivo
asociado con su argumento.

El prototipo de la función fflush() es:

int fflush (FILE *pt);

donde:

- pt, es el "puntero a archivo" devuelto por fopen().

 10

La función fflush() devuelve 0 si se tiene éxito, en otro caso devuelve EOF.

Por ejemplo, para vaciar el flujo de la entrada estándar (teclado) se utiliza la siguiente sentencia:

fflush (stdin);

Si se llama a fflush() con un puntero NULL se vacían los buffers de todos los archivos abiertos.

Un buffer es un área de almacenamiento temporal en memoria para el conjunto de datos leídos

o escritos en el archivo. Estos buffers retienen datos en tránsito desde y hacia al archivo y tienen
la finalidad de hacer más eficiente las operaciones de entrada/salida en los archivos de disco,
provocando menor cantidad de accesos, los cuales son más lentos que la memoria. P. ejem. Si
se requiere consultar constantemente un dato del archivo, no es necesario calcular su dirección
física, reposicionar el apuntador del archivo, “cargar” el dato en memoria mediante una
operación de lectura cada vez que se necesita, sino que el sistema operativo controla y mantiene
este dato en los buffers de memoria y de ahí lo toma cuando lo requiera. Sólo hay una
consideración importante al utilizar los buffers, los datos escritos en ellos no se reflejan
exactamente en los archivos de disco en forma inmediata, sino hasta que se “vacía” el buffer.
Para ello se utiliza la función fflush y basta enviarle el alias del archivo como argumento. Los
buffers también se vacían cuando se cierra el archivo.

13. DETERMINACIÓN DE ERRORES: ferror()

La función ferror() determina si se ha producido un error en una operación de lectura o escritura

sobre un archivo.

El prototipo de la función ferror() es:

int ferror (FILE *pt)

donde:

- pt, es el "puntero a archivo" devuelto por fopen().

La función ferror() devuelve verdadero si se ha producido un error durante la última operación

sobre el archivo, caso contrario devuelve falso.
 11

Se debe tener en cuenta que en cada operación sobre un archivo se actualiza la condición de
error, por esto se debe llamar a ferror() inmediatamente después de cada operación de este tipo,
si no se hace así el error no podrá ser detectado.

14. FLUJO DE DATOS BINARIOS

Estas operaciones funcionan con las mismas reglas que otra expresión en C

14.1. Lectura y escritura: fread() y fwrite()

Estas operaciones funcionan con las mismas reglas que otra expresión en C

14.2. E/S de acceso directo: fseek()

14.3. Valor del indicador de posición del archivo: ftell()

15. ESCRITURA Y LECTURA DE CUALQUIER TIPO DE DATOS: fprintf() y

fscanf()

Estas operaciones funcionan con las mismas reglas que otra expresión en C

16. CONEXIÓN ENTRE LA CONSOLA Y LA E/S DE ARCHIVOS

16.1. Utilización de las funciones de archivos para consola

16.2. Utilización de las funciones de consola para archivos
 12

Programas en C
 13

Conclusiones y Recomendaciones
Conclusiones

 Aunque existe una gran diversidad de aplicaciones que se pueden desarrollar con manejo de archivos
que pueden ser sumamente completas y complejas, estos apuntes presentan, de una forma sencilla
y comprensible, los aspectos básicos de programación de archivos usando lenguaje C. De tal forma,
que no presenta lógica abrumadora de control de detalles, sino la base fundamental del material es
entender y utilizar las funciones básicas de manejo de archivos en este lenguaje para posteriormente
usarlas en cursos superiores o vida laboral.

Recomendaciones

 En los programas que se escriban se debe intentar evitar declaraciones complejas que dificulten la
legibilidad del programa. Una forma de conseguirlo es utilizando typedef para redefinir/renombrar
tipos.
 14

Referencias

archivos.pdf. (n.d.). Retrieved from https://w3.ual.es/~abecerra/ID/archivos

Kernighan, B. W., Ritchie, D. M., Gómez Muñoz, N., & Frid, D. (1991). El Lenguaje de programación C.

México, D.F.: Prentice-Hall Hispanoamericana.

Mv, B. (n.d.). Manejo de Archivos en C. Retrieved from

https://www.academia.edu/7334210/Manejo_de_Archivos_en_C