Hemos aprendido distintas estructuras de datos que nos permiten administrar información en la memoria ram de nuestra computadora.
Ahora veremos otra estructura de datos que nos permite almacenar datos en una memoria secundaria de nuestra computadora como podría ser el disco duro, pendrive etc.
Esta estructura de datos son los archivos. Un archivo veremos que es independiente a nuestro programa y podrá ser accedido luego por otros programas.
Un archivo podemos imaginarlo en forma similar a un vector. También en un archivo los distintos componentes (bytes) se ubican uno a continuación del otro, y al igual que en los vectores, los componentes de un archivo en C también son automáticamente numerados con índices, desde el 0 (cero) en adelante. Pero la forma de procesar un archivo difiere totalmente con respecto a un vector.
Podemos clasificar los archivos según el formato como se guardan los datos en:
- Archivos binarios
- Archivos de texto
En este y próximos conceptos veremos como administrar los archivos binarios y luego cuando veamos los archivos de texto veremos sus semejanzas y diferencias.
Problema 1:
Crear un archivo binario y almacenar un caracter, un entero y un float. Identificar en el disco duro el archivo creado y cual es su tamaño en bytes.
Archivo: programa216.c
#include<stdio.h>
#include<conio.h>
#include<stdlib.h>
int main()
{
FILE *arch;
arch=fopen("archivo1.dat","wb");
if (arch==NULL)
exit(1);
char letra='A';
fwrite(&letra, sizeof(char), 1, arch);
int valor1=12;
fwrite(&valor1, sizeof(int), 1, arch);
float valor2=5.25;
fwrite(&valor2, sizeof(float), 1, arch);
fclose(arch);
printf("Se creo un archivo binario que almacena un char, un int y un float.");
getch();
return 0;
}
Luego de ejecutar este programa debería haberse creado en la misma carpeta donde tenemos nuestro programa un archivo llamado "archivo1.dat":
Existen un conjunto de funciones que nos permiten administrar archivos binarios en el lenguaje C y se encuentran declaradas en el archivo de inclusión: #include<stdio.h>
Además para trabajar con archivos debemos definir un puntero del tipo de dato FILE que se encuentra declarado también en #include<stdio.h>
Podemos abrir con un editor de texto el archivo stdio.h (se encuentra en C:\Program Files (x86)\CodeBlocks\MinGW\include) y ubicar en su interior la declaración del tipo FILE:
typedef struct _iobuf
{
char* _ptr;
int _cnt;
char* _base;
int _flag;
int _file;
int _charbuf;
int _bufsiz;
char* _tmpfname;
} FILE;
La estructura de este registro no nos importa ya que son las funciones que provee la librería stdio.h las que la utilizan.
Entonces volvamos a nuestro programa, lo primero que hacemos es definir un puntero del tipo FILE:
#include<stdio.h>
#include<conio.h>
#include<stdlib.h>
int main()
{
FILE *arch;
Una vez definida la variable arch procedemos a llamar a la función fopen con dos parámetros que indican el nombre físico del archivo ("archivo1.dat") y la forma de apertura y tipo de archivo:
arch=fopen("archivo1.dat","wb");
El primer parámetro indicamos el nombre del archivo a crear, debe ser un nombre válido para el sistema operativo donde se ejecuta.
Con "wb" estamos pidiendo a fopen que cree el archivo binario (si ya existe se borra el actual y se crea uno nuevo vacío)
Finalmente la función fopen retorna un puntero de tipo FILE y se almacena en la variable arch (arch es el nombre lógico del archivo que hacemos referencia dentro de nuestro programa y se relaciona con el archivo "archivo1.dat")
Es importante controlar si el archivo no se pudo crear verificando si el puntero almacena el valor NULL:
if (arch==NULL)
exit(1);
El archivo podría no crearse porque el disco duro esta lleno, porque hay otro archivo con el mismo nombre y esta siendo procesado por otro programa etc.
Si en arch se almacena un valor distinto a NULL luego ya tenemos creado el archivo "archivo1.dat" listo para grabar datos en el mismo.
Inmediatamente luego que se crea el archivo no contiene información, para almacenar datos en el archivo utilizaremos la función fwrite:
char letra='A';
fwrite(&letra, sizeof(char), 1, arch);
La función fwrite tiene 4 parámetros:
- Al primer parámetro hay que pasar la dirección de la variable a grabar en el archivo.
- Al segundo parámetro hay que pasar la cantidad de bytes del tipo de datos a grabar. Normalmente utilizamos el operador sizeof para recuperar el tamaño.
- El tercer parámetro le pasamos un 1 ya que guardamos solo una variable (tendrá sentido cuando grabemos todo un vector con una sola llamada)
- El cuarto parámetro es el nombre lógico del archivo.
Si volvemos a llamar a la función fwrite el nuevo dato se almacena en el archivo a continuación del último grabado:
int valor1=12;
fwrite(&valor1, sizeof(int), 1, arch);
float valor2=5.25;
fwrite(&valor2, sizeof(float), 1, arch);
Como hemos grabado un char (1 byte), un int (4 bytes) y un float (4 bytes) luego podemos verificar que el archivo creado tiene 9 bytes de tamaño:
Cuando no necesitamos trabajar más con el archivo llamamos a la función fclose para liberar el archivo y que pueda ser procesado por otro programa:
fclose(arch);
Es fundamental entender que el archivo "archivo1.dat" no se pierde cuando finaliza la ejecución del programa.