Manejo de archivo
Introducción
¡Felicidades por haber llegado hasta este momento! Estas llegando casi al final de tu Unidad de Aprendizaje de Programación Básica, ahora, eres capaz de desarrollar código con una secuencia lógica y una semántica, has aprendido cuales la estructura de un lenguaje de programación, su sintaxis, etc.
Ahora entraremos a un tema maravilloso, que es sumamente importante para el área computacional, para ello es importante que te preguntes ¿en dónde almacenaras los resultados y datos?, la generación de resultados y el almacenamiento de datos nos han permitido el importante crecimiento computacional, el almacenar información nos permite acceder a conocimiento del pasado o porque te sirve a realizar un análisis de lo existente y generar resultados nuevos a partir de ello, de aquí que nace el manejo de archivos.
Un archivo es un depósito, repositorio o reservorio de almacenamiento computacional de datos.
¿Por qué es importante el manejo de archivos en el área de programación?
Cuando estas programando y generas resultados de tus programas, al cerrarlos, pierdes los datos que generaste de tu programación, por tanto, es maravilloso el que puedas preservar esa información aun cerrando o finalizando tu programa.
Si a un programa debes introducir miles de datos para procesarlos dentro de tu código de programación, te será más fácil introducirlos por medio de un archivo para su procesamiento, para no teclearlos uno a uno.
Si aprendes a manejar archivos podrás fácilmente trasladar tu información o datos de un dispositivo a otro y compartirlos.
Comencemos por conocer cómo funciona y terminemos practicando esta maravilla.
! Bienvenidas y bienvenidos ¡
Desarrollo del tema
¿Qué es el manejo de archivos en C?
Un archivo es un repositorio en la que un programa almacena datos o información, esta información se almacena en bytes en manera permanente, por tanto, la información deja de ser volátil como la memoria del compilador. Las operaciones que se pueden realizar con los archivos es crear, abrir, leer y manipular los datos que están dentro del archivo, a todas estas operaciones se les llama manejo de archivo.
Tipos de archivos
Lenguaje C maneja dos tipos de archivo:
Archivos de texto: el archivo de tipo texto es el más usado por los usuarios, un archivo de texto usa la extensión “.txt”, este archivo almacena datos en forma de caracteres ASCII, por tanto, cuando el usuario, programador o humano abre el archivo, puede leer el contenido. Este tipo de archivo son muy fáciles de acceder y utilizar. Desventajas de este tipo de archivo, si la información que almacena es sensible cualquier persona que tenga acceso podrá leer el contenido y los archivos de texto consumen mas espacio de almacenamiento que un archivo tipo binario. El archivo de tipo texto (txt) puede ser editable y abierto por cualquier editor de texto: Microsoft Word, Notepad, Apple Text Edit, gedit e Emacs de Linux, etc.
Archivos binarios: el archivo de tipo binario almacena información o datos en formato de 0 y 1 (sistema binario), esto hace que el peso de almacenamiento sea menor que un txt, por tanto, los archivos binarios almacenan los datos dentro de ellos de la misma forma que el computador (el humano no puede leerlo solo el computador), el acceso y lectura también son más rápidos en comparación que un txt. Los archivos binarios se crean con la extensión “.bin”, los archivos de datos binario son los más seguros en términos de almacenamiento
Operaciones con archivos
Podemos ejecutar varias funciones para abrir un archivo, leer, escribir en un archivo, agregar más datos a un archivo, crear un archivo nuevo, cerrar o eliminar un archivo, buscar un archivo, etc. Estos se conocen como operadores de manejo de archivos en C.
| Descripción | Función |
| Abre un archivo existente o un archivo nuevo. | fopen() |
| Escribe datos en un archivo existente o en un archivo nuevo | fprintf() |
| Lee datos en un archivo existente | fscanf() |
| Escribe un carácter en un archivo existente | fputc() |
| Escribe una cadena en un archivo | fputs() |
| Lee un carácter desde un archivo existente | fgetc() |
| Lee una cadena en un archivo existente | fgets() |
| Cierra un archivo existente | fclose() |
| Posiciona el puntero en algún lugar del archivo existente (busca un byte especifico) | fseek() |
| Escribe un entero en un archivo existente | fputw() |
| Lee un entero en un archivo existente | fgetw() |
| Lee un archivo desde una posición dentro de un archivo existente | ftell() |
| Se posiciona al principio del archivo | frewind() |
| Devuelve un verdadero si llega al final de un archivo existente | feof() |
| Devuelve un verdadero si se produce un error durante una operación de archivo | ferror() |
| Borra un archivo existente | fremove() |
| Vacía un archivo existente | fflush() |
Debemos declarar un puntero de tipo archivo cuando estamos trabajando con varios archivos en un mismo programa, esto lleva a cabo la comunicación entre el programa y los archivos involucrados.
FILE* fpuntero;
En seguida veremos ahora todos los moods con los que podemos operar en la función fopen()
| Descripción | Atributos (moods) |
| Abre un archivo para leer su contenido. Si el archivo no existe en la ubicación, fopen() devolverá un NULL. | r |
| Abre un archivo para leer su contenido en modo binario. Si el archivo no existe en la ubicación, fopen() devolverá un NULL. | rb |
| Abre un archivo para escribir. Si el archivo ya existe, el contenido se sobrescribe. Si el archivo no existe en la ubicación, creará un archivo nuevo. | w |
| Abre un archivo para escribir en modo binario. Si el archivo ya existe, el contenido se sobrescribe. Si el archivo no existe en la ubicación, creará un archivo nuevo. | wb |
| Abre un archivo para agregar datos al final del archivo. Si el archivo no existe en la ubicación, creará un archivo nuevo. | a |
| Abre un archivo para agregar datos escritos en binario, los datos del programa se agregan al final del archivo. Si el archivo no existe en la ubicación, creará un archivo nuevo. | ab |
| Abre un archivo para escribir y leer su contenido. Si el archivo no existe en la ubicación, fopen() devolverá NULL. | r+ |
| Abre un archivo para escribir y leer su contenido en binario. Si el archivo no existe en la ubicación, fopen() devolverá NULL. | rb+ |
| Abre un archivo para escribir y leer en el archivo. Si el archivo ya existe, el contenido se sobrescribe. Si el archivo no existe en la ubicación, creará un archivo nuevo. | w+ |
| Abre un archivo para escribir y leer en modo binario. Si el archivo ya existe, el contenido se sobrescribe. Si el archivo no existe en la ubicación, creará un archivo nuevo. | wb+ |
Ahora que ya tenemos la teoría, vamos a la práctica.
Ejemplo 1. Apertura de un archivo.
#include <stdio.h>
#include <stdlib.h>
int main()
{
FILE* fpuntero; //FILE es la variable puntero para almacenar el valor de retorno fopen()
fpuntero = fopen(«aperturaf.txt», «r»); // abre un archivo en modo lectura «read», recuerda que, si no existe regresara un NULL
// verifica si el archivo se abrió satisfactoriamente
if (fpuntero == NULL) {
printf(«El archivo no pudo ser abierto. El programa terminara ahora»);
exit(0);
}
return 0;
}
Salida 1, Ejemplo 1. El archivo no existe en la ubicación. (toma como ubicación inmediata donde se encuentra almacenado el archivo.c, en este caso se llama aperturaf.txt).
Salida 2. Ejemplo 1. El archivo existe en la ubicación
Ejemplo 2. Creación de un archivo
#include <stdio.h>
#include <stdlib.h>
int main()
{
FILE* fpuntero; //FILE es la variable puntero para almacenar el valor de retorno fopen()
fpuntero = fopen(«creaf.txt», «w»); // Escribe en un archivo, recuerda: si existe el archivo lo sobreescribe, si no existe lo crea
// verifica si el archivo se haya creado
if (fpuntero == NULL) {
printf(«El archivo no pudo ser abierto. El programa terminara ahora»);
exit(0);
}
else {
printf(«El archivo fue creado o sobrescrito exitosamente.»);
}
return 0;
}
Salida Ejemplo 2. Creación de un archivo.
Ejemplo 3. Lee desde un archivo
#include <stdio.h>
#include <stdlib.h>
int main()
{
FILE* fpuntero; //FILE es la variable puntero para almacenar el valor de retorno fopen()
char cad1[10];
fpuntero = fopen(«leerf.txt», «r»); // abre un archivo en modo lectura «read», recuerda que si no existe regresara un NULL
fscanf(fpuntero, «%s», cad1);
char c = fgetc(fpuntero); //obtiene el caracter
// verifica si el archivo exista
if (fpuntero == NULL) {
printf(«El archivo no pudo ser abierto. El programa terminara ahora»);
exit(0);
}
return 0;
}
Salida. Ejemplo 3. Como ha leído el archivo, no marca ningún error.
Ejemplo 4. Escribe en un archivo.
#include <stdio.h>
#include <stdlib.h>
int main()
{
FILE* fpuntero; //FILE es la variable puntero para almacenar el valor de retorno fopen()
fpuntero = fopen(«escribef.txt», «w»); // Escribe en un archivo, recuerda: si existe el archivo lo sobreescribe, si no existe lo crea
fprintf(fpuntero, «%s», «Lenguaje de programacion en C «);
fputc(«a», fpuntero);
// verifica si el archivo se haya creado
if (fpuntero == NULL) {
printf(«El archivo no pudo ser abierto. El programa terminara ahora»);
exit(0);
}
else {
printf(«El archivo fue creado o sobrescrito exitosamente.»);
}
return 0;
}
Salida. Ejemplo 4. Escribe o sobrescribe en un archivo.
Archivo de salida. Ejemplo 4. Escribe o sobrescribe en un archivo.
Podemos verificar que el Sistema Operativo (en el caso de este compilador se escribió en Sistema Operativo Windows, coloca la marca de finalización de archivo EOF con “/”, la marca de finalización de archivo puede variar por sistema operativo y comunicación con su compilador).
Ejemplo 5. Crea un archivo, escribe en él y cierra el archivo.
int main()
{
FILE* fpuntero;
char datos[50] = «Lenguaje de programacion en C «
«y Manejo de Archivos»; // Datos que escribira en el archivo
fpuntero = fopen(«archivo.txt», «w»);
if (fpuntero == NULL) {
printf(«Fallo la apertura del archivo archivo.txt»);
}
else {
printf(«El archivo se ha abierto exitosamente\n»);
// los datos se estaran escribiendo en el archivo
if (strlen(datos) > 0) {
// fputs() escribe
fputs(datos, fpuntero);
fputs(«\n», fpuntero);
}
fclose(fpuntero); // cerramos el archivo
printf(«Los datos se han escrito en el archivo «
«archivo.txt\n»);
printf(«Se ha cerrado el archivo.»);
}
return 0;
}
Salida. Ejemplo 5. Compilación.
#include <stdio.h>
#include <string.h>
int main()
{
FILE* fpuntero;
char datos[50];
fpuntero = fopen(«leedatos.txt», «r»);
if (fpuntero == NULL) {
printf(«La apertura de leedatos.txt ha fallado»);
}
else {
printf(«El archivo se ha abierto.\n»);
// Lee la variable_cadena «datos» desde el archivo usando fgets()
while (fgets(datos, 50, fpuntero)
!= NULL) {
printf(«%s», datos); // Imprime lo almacenado en el vector
}
fclose(fpuntero); //cierra el archivo
printf(«Los datos almacenados en leedatos.txt han sido leidos. \n»);
printf(«El archivo ahora esta cerrado.»);
}
return 0;
}
Salida 1. Ejemplo 6. Si el archivo no existe.
Salida 2. Ejemplo 6. El archivo existe.
Ejemplo 7. Lee un archivo, solicitando al usuario el nombre del archivo a leer.
#include <stdio.h>
#include <stdlib.h>
int main()
{
FILE *fpuntero;
char nom_archivo[100], cadena;
printf(«Escribe el nombre y extension de tu archivo a leer: «);
scanf(«%s», nom_archivo);
fpuntero = fopen(nom_archivo, «r»);
if (fpuntero == NULL)
{
printf(«No se pudo abrir el archivo \n»);
exit(0);
}
cadena = fgetc(fpuntero); // Lee el contenido del archivo
while (cadena != EOF)
{
printf («%c», cadena);
cadena = fgetc(fpuntero);
}
fclose(fpuntero);
return 0;
}
Salida 1. Ejemplo 7. No encuentra archivo.
Salida 2. Ejemplo 7. Encuentra el archivo del que ha solicitado: nombre de archivo a leer.
Hasta ahora, hemos colocado algunos ejemplos, para que, por favor, los practiques en tu ordenador o compilador online de tu preferencia, y para que sigas aprendiendo al respecto al Manejo de Archivos colocamos algunos sitios web que puedes sigas ampliando tu conocimiento:
Página: Java T Point
Página: Programiz
Sigue practicando, cada ejercicio te permitirá a ti almacenar conocimiento y experiencia en tu cerebro.
Conclusión
Ahora que conocemos la importancia del manejo de archivos hagamos un resumen de ello.
Es importante almacenar información ya que, una vez finalizado el programa, se pierden los datos que han sido procesados, para ello es preciso conservar la información en archivos, para poder consultarlos posteriormente y no tener que ejecutar nuevamente el programa.
En lenguaje C podemos crear dos tipos de archivo:
- Texto (.txt)
- Binario (.bin)
Algunas de las funciones para el manejo de archivo:
- fopen(); usada para abrir un archivo existente o crear un archivo nuevo
- fprintf(); usada para escribir caracteres en un archivo existente
- fscanf(); usada para leer caracteres del archivo
- fputs(); usada para escribir una cadena en un archivo existente
- fgets(); usada para leer una cadena del archivo
- fclose(); usada para cerrar el archivo
Listamos los atributos que se pueden usar para la apertura del manejo de archivo más importantes:
- Leer («r»)
- Escribir(«w»)
- Agregar(«a»)
Los ejercicios que te presentamos en la sesión, cópialos y ejecútalos en tu compilador, para que verifiques las salidas. Sigue practicando, agregando operaciones en tus códigos y que sus resultados se almacenen en los archivos.
Fuentes de información
- Gottfried, B. S. (2005). Programación en C. McGraw-Hill Interamericana.
- Schildt H (1991), Programación en TURBO C. McGraw-Hill.
- C Programming Language, Brian W. Kernighan Dennis M. Ritchie. Prentice Hall; 2 ed.