Utilisation efficace de la mémoire avec les champs de bits en C

Supposons un programme C avec plusieurs variables VRAI/FAUX groupées dans une structure status :

struct {
    unsigned int widthValidated;
    unsigned int heightValidated;
} status;

Cette structure prend 8 octets (2 int), mais ne stocke que 0 ou 1. Le C offre une meilleure utilisation mémoire : les champs de bits.

Définissez la largeur d'une variable pour indiquer au compilateur le nombre de bits utilisés :

struct {
    unsigned int widthValidated : 1;
    unsigned int heightValidated : 1;
} status;

Cette structure ne prend que 4 octets (taille d'un int), mais n'utilise que 2 bits.

Jusqu'à 32 variables de 1 bit → 4 octets. 33 variables → 8 octets (prochain mot mémoire).

Exemple comparatif

#include <stdio.h>
#include <string.h>

struct { unsigned int widthValidated; unsigned int heightValidated; } status1;
struct { unsigned int widthValidated : 1; unsigned int heightValidated : 1; } status2;

int main() {
    printf("Taille status1 (normal) : %zu octets\n", sizeof(status1));
    printf("Taille status2 (bit fields) : %zu octets\n", sizeof(status2));
    return 0;
}

Résultat :

Taille status1 (normal) : 8 octets
Taille status2 (bit fields) : 4 octets

Déclaration d'un champ de bits

Forme dans une structure :

struct { type [nom_membre] : largeur; };

N°	Élément et description
1	type : type entier (int, signed int, unsigned int) déterminant l'interprétation.
2	nom_membre : nom du champ de bits.
3	largeur : nombre de bits (≤ largeur du type spécifié).

Variables avec largeur prédéfinie = champs de bits. Peuvent contenir plus d'un bit. Exemple : valeur 0-7 → largeur 3 bits :

struct { unsigned int age : 3; } Age;

Le compilateur n'autorise pas plus de 3 bits. Test :

#include <stdio.h>
#include <string.h>
struct { unsigned int age : 3; } Age;
int main() {
    Age.age = 4; printf("Taille: %zu, age: %d\n", sizeof(Age), Age.age);
    Age.age = 7; printf("age: %d\n", Age.age);
    Age.age = 8; printf("age: %d\n", Age.age);  // débordement
    return 0;
}

Résultat (avec avertissement compilation) :

Taille: 4
age: 4
age: 7
age: 0  // 8 = 1000b, tronqué à 3 bits = 000b = 0