Cuando trabajamos con archivos en C, normalmente pensamos en guardar texto, caracteres o cadenas que podamos leer fácilmente con un editor. Sin embargo, cuando manejamos datos más complejos, como estructuras con múltiples campos de distintos tipos, esta forma de almacenamiento se vuelve poco práctica. Convertir cada campo a texto y luego parsearlo para recuperarlo puede ser tedioso y poco eficiente.
En lugar de eso, podemos aprovechar que en memoria todo se representa como bytes. Por ejemplo, si tenemos una estructura que almacena una medición con campos para año, mes, día, temperatura, índice ultravioleta y viento, todos esos datos están almacenados contiguamente en memoria como una secuencia de bytes. En C, podemos tratar esa estructura no como un conjunto de variables, sino como un bloque de memoria, un buffer, y volcarlo directamente a un archivo binario.
Para hacer esto, usamos la función fwrite. Esta función nos permite escribir en un archivo un bloque de memoria, sin importar el tipo de datos que contenga. Su primer parámetro es un puntero void * que apunta al inicio del buffer que queremos escribir. Esto significa que no importa si es un puntero a una estructura, a un entero o a un flotante; fwrite solo ve bytes.
El segundo parámetro es el tamaño en bytes de cada elemento que queremos escribir. Normalmente usamos sizeof para obtener el tamaño exacto de la estructura o del tipo de dato que estamos guardando, asegurándonos de escribir la cantidad correcta de bytes.
El tercer parámetro indica cuántos elementos de ese tamaño queremos escribir. Por ejemplo, si tenemos un array de estructuras, podemos pedir que se escriban varias consecutivamente. En nuestro caso, si solo queremos escribir una estructura, ponemos uno.
Finalmente, el cuarto parámetro es el puntero al archivo abierto con fopen. Es importante abrir el archivo en modo binario, usando "wb", para evitar que el sistema operativo realice transformaciones automáticas en los bytes, como convertir saltos de línea, lo que podría corromper los datos.
Veamos un ejemplo sencillo que ilustra cómo escribir una estructura en un archivo binario:
#include <stdio.h>
struct medicion {
int año;
int mes;
int dia;
float temperatura;
int indice_uv;
int viento;
};
int main() {
struct medicion medida = {2020, 11, 9, 12.5f, 4, 15};
FILE *fp = fopen("temperatura.bin", "wb");
if (fp == NULL) {
perror("Error al abrir el archivo");
return 1;
}
size_t elementos_escritos = fwrite(&medida, sizeof(struct medicion), 1, fp);
if (elementos_escritos != 1) {
perror("Error al escribir en el archivo");
fclose(fp);
return 1;
}
fclose(fp);
return 0;
}
En este código, definimos la estructura medicion con varios campos. Creamos una variable medida con valores concretos. Abrimos un archivo binario para escritura y usamos fwrite para volcar la estructura completa en el archivo. Comprobamos que la escritura haya sido exitosa y cerramos el archivo.
Al abrir el archivo resultante con un editor de texto, veremos caracteres extraños o basura, porque no es un archivo de texto sino un archivo binario que contiene la representación en bytes de la estructura. Para inspeccionarlo, podemos usar herramientas como xxd en sistemas Unix, que muestran el contenido hexadecimal del archivo.
Este método es muy eficiente para guardar y recuperar datos complejos, ya que evita la conversión a texto y la posterior interpretación. En próximas ocasiones veremos cómo leer estos datos con fread para reconstruir las estructuras en memoria. Por ahora, hemos dado un paso importante para manejar archivos binarios en C y trabajar directamente con bloques de memoria.