Los bit fields (campos de bits) son miembros de una estructura a los que se les asigna un ancho de bits específico mediante la sintaxis : n. En lugar de que cada miembro ocupe el tamaño estándar de su tipo (como los 4 bytes habituales de un int), el compilador intenta agrupar estos campos dentro de una única unidad de almacenamiento, optimizando el uso de la memoria.
Esto funciona porque el compilador utiliza instrucciones de bitwise (AND, OR, SHL, SHR) para extraer o insertar los valores en la posición exacta de la palabra de memoria asignada. Es una técnica fundamental cuando necesitas que un struct coincida con un registro de hardware real o cuando trabajas en sistemas con memoria extremadamente limitada. Sin embargo, su uso principal es para flags de estado o valores pequeños (como un enumerado de 3 bits) que, de otro modo, desperdiciarían bytes enteros.
Debes usarlos cuando el diseño de tu software sea exclusivo para una arquitectura específica o cuando estés gestionando recursos internos del kernel o drivers donde el ahorro de memoria sea crítico. No obstante, debes tener mucho cuidado: si intentas usar bit fields para mapear un protocolo de red o un formato de archivo para ser leído en diferentes máquinas, romperás la compatibilidad. El estándar de C no define el orden de los bits (si el primer campo es el bit más significativo o el menos significativo) ni el padding (relleno) que el compilador inserta entre campos o al final de la estructura. Si el diseño es para comunicación entre sistemas distintos, es preferible la manipulación manual de bits con máscaras.
Si los usas incorrectamente, especialmente con tipos con signo, puedes encontrarte con valores inesperados debido a la extensión de signo, o con errores de alineación que degradan el rendimiento de la CPU.
#include <stdio.h>
#include <stdint.h>
/* Representación compacta de un estado de dispositivo */
typedef struct {
unsigned int encendido : 1; /* 1 bit: 0 o 1 */
unsigned int modo : 3; /* 3 bits: valores 0-7 */
unsigned int nivel_err : 2; /* 2 bits: valores 0-3 */
unsigned int reserva : 6; /* 6 bits para completar un byte (si fuera char) */
} EstadoCompacto;
/* Representación estándar (sin empaquetado) */
typedef struct {
unsigned char encendido;
unsigned char modo;
unsigned char nivel_err;
} EstadoEstandar;
int main(void) {
/* Inicialización de la estructura empaquetada */
EstadoCompacto estado = {
.encendido = 1,
.modo = 5, /* 101 en binario */
.nivel_err = 2, /* 10 en binario */
.reserva = 0
};
EstadoEstandar est_std = {1, 5, 2};
printf("Tamaño de EstadoCompacto: %zu bytes\n", sizeof(EstadoCompacto));
printf("Tamaño de EstadoEstandar: %zu bytes\n", sizeof(EstadoEstandar));
/* Verificación de la empaquetación */
if (sizeof(EstadoCompacto) < sizeof(EstadoEstandar)) {
printf("Éxito: El empaquetado redujo el tamaño de la estructura.\n");
}
/* El acceso a los miembros sigue siendo igual que en un struct normal */
if (estado.encendido) {
printf("Dispositivo en modo %u con error nivel %u\n", estado.modo, estado.nivel_err);
}
return 0;
}
Análisis del ejemplo
En el código anterior, la estructura EstadoCompacto utiliza campos de bits para definir cuatro miembros. Aunque declaramos unsigned int como base, el compilador no reserva 4 bytes para cada uno. En su lugar, observa que la suma de los bits (1 + 3 + 2 + 6 = 12 bits, aunque aquí hemos añadido reserva para facilitar la comprensión) cabe dentro de una unidad de almacenamiento.
Al ejecutar el programa, observarás que sizeof(EstadoCompacto) es significativamente menor que sizeof(EstadoEstandar). El compilador ha agrupado encendido, modo y nivel_err en una única palabra de memoria. Nota que, aunque la suma de bits sea 12, sizeof devolverá el tamaño de la unidad de almacenamiento más cercana (probablemente 4 bytes si el compilador alinea por int).
Es vital usar unsigned int [C11] en los bit fields. Si usáramos int (con signo), el bit de mayor peso de ese campo podría interpretarse como el bit de signo, lo que daría resultados matemáticos erróneos al manipular los valores.
El miembro reserva es una técnica común para asegurar que la estructura tenga un tamaño predecible o para alinearse con los límites de un registro de hardware específico, evitando que el compilador inserte padding implícito de forma descontrolada.
El error frecuente
Un error clásico es usar tipos con signo en campos de un solo bit. Fíjate en este escenario:
struct Error:
int activo : 1; // ¡Peligro!
end
Si intentas asignar 1 a activo, y el compilador trata el campo como un int con signo, el bit 1 es el bit de signo. Al intentar leer el valor, el programa podría interpretar que activo es -1 en lugar de 1, debido a la representación en complemento a dos.
Este tipo de errores es difícil de detectar porque el código compila perfectamente, pero genera comportamientos erráticos en comparaciones como if (estado.activo == 1). Siempre, sin excepción, utiliza unsigned int o _Bool [C99] para campos de bits donde solo necesites estados binarios o valores numéricos positivos. Además, herramientas como UBSan (Undefined Behavior Sanitizer) pueden ayudar a detectar inconsistencias de signo, pero la mejor defensa es el diseño correcto desde el inicio.
N° 63