Mémoire, octets et adresses en C

Le langage C range chaque variable dans des cases de mémoire appelées octets, et le programmeur doit savoir combien elle en prend. Connaître la taille d’une variable et son adresse explique des erreurs qui n’affichent aucun message.

Un logiciel de caisse garde un million de lignes de vente. Chaque ligne a un code d’un octet, une quantité de quatre octets et un rayon d’un octet. Six octets, donc six mégaoctets ? Non : douze. Cette leçon explique pourquoi.

Un type dit à la fois quelle sorte de valeur une variable contient et combien d’octets elle prend. Le mot sizeof donne cette taille, et le compilateur la calcule avant même que le programme tourne.

Le type char prend un octet, short deux, int quatre et double huit. Le type long dépend du système : huit octets sous Linux, quatre sous d’autres systèmes. Demandez-le toujours à sizeof.

#include <stdio.h>

int main(void) {
    printf("%zu %zu %zu %zu\n", sizeof(char), sizeof(short),
           sizeof(int), sizeof(double));
    return 0;
}

mkdir -p ~/c && cd ~/c

printf '#include <stdio.h>\nint main(void) {\n    printf("%%zu %%zu %%zu %%zu\\n", sizeof(char), sizeof(short), sizeof(int), sizeof(double));\n    return 0;\n}\n' > tailles.c

gcc -Wall -o tailles tailles.c && ./tailles

Imaginez la mémoire comme une longue rangée de casiers numérotés. Chaque casier est un octet, et son numéro est son adresse. Un int occupe quatre casiers qui se suivent, et son adresse est celle du premier.

Les adresses s’écrivent en hexadécimal et changent d’un lancement à l’autre. Les leçons ne citent donc jamais une adresse : elles décrivent sa forme.

Le nombre 258 vaut 1 × 256 + 2. Les processeurs courants rangent d’abord l’octet qui pèse le moins, ici 2, puis celui qui pèse 256, ici 1. On dit petit-boutiste (little endian en anglais).

Lire ces quatre octets dans l’ordre inverse donnerait un tout autre nombre.

Un processeur lit vite un int posé sur une adresse multiple de quatre. Le compilateur respecte donc l’alignement : il saute quelques octets pour placer chaque champ d’une structure sur un multiple de sa taille. Ces octets perdus forment le remplissage.

La structure a ci-dessous a un char, un int puis un char. La structure b a les mêmes champs dans un autre ordre.

struct a { char c; int n; char d; };
struct b { int n; char c; char d; };

printf '#include <stdio.h>\n#include <stddef.h>\nstruct a { char c; int n; char d; };\nstruct b { int n; char c; char d; };\nint main(void) {\n    printf("%%zu %%zu\\n", sizeof(struct a), sizeof(struct b));\n    printf("%%zu %%zu\\n", offsetof(struct a, n), offsetof(struct a, d));\n    return 0;\n}\n' > champs.c

gcc -Wall -o champs champs.c && ./champs