Structures et fichiers

1struct Mesure {2    char   capteur;      /* 1 octet  */3    int    valeur;       /* 4 octets */4    char   unite;        /* 1 octet  */5};6printf("%zu\n", sizeof(struct Mesure));    /* affiche 12, pas 6 */

Six octets de données, douze octets occupés. La moitié de la structure est du vide — et il suffit de réordonner les champs pour retomber à huit. Ce chapitre explique pourquoi, puis donne aux données ce qui leur manque encore : la capacité de survivre à la fin du programme.

Se donner ses propres types

Une structure regroupe des champs de types différents sous un seul nom.

1typedef struct {2    char nom[32];3    int  age;4    double note;5} Etudiant;6 7Etudiant e = {"Ana", 20, 15.5};8printf("%s a %d ans\n", e.nom, e.age);

Le typedef évite d'écrire struct Etudiant à chaque emploi. Il y a une exception à connaître : une structure qui se référence elle-même doit garder son étiquette, parce que le typedef n'existe pas encore au moment où le champ est déclaré.

1typedef struct Cellule {2    int valeur;3    struct Cellule *suivant;     /* « struct Cellule », pas « Cellule » */4} Cellule;

C'est la cellule du chapitre 8, et c'est la forme qu'il faut connaître par cœur : elle revient dans toutes les structures chaînées d'Algorithmique 2.

Un point qui distingue les structures des tableaux, et qui surprend : une structure est copiée. L'affectation a = b recopie tous les champs, et le passage en paramètre aussi — ce qui est le comportement du chapitre 4, sans l'exception du chapitre 5. Sur une structure volumineuse, on passe donc un pointeur, déclaré const si l'on ne modifie pas.

Attention toutefois : la copie est superficielle. Un champ char * est copié en tant qu'adresse, donc les deux structures désignent la même chaîne — et un free des deux côtés donne le double free du chapitre 8.

Alignement et bourrage

Voici l'explication des douze octets.

Le processeur lit la mémoire par mots, et il exige — ou préfère fortement — qu'une donnée de $k$ octets commence à une adresse multiple de $k$. Le compilateur insère donc du bourrage (padding) entre les champs pour respecter cet alignement.

1struct Mesure { char capteur; int valeur; char unite; };2 3octet :  0     1  2  3     4  5  6  7     8     9 10 114       ┌─────┬───────────┬─────────────┬─────┬──────────┐5       │ cap │  bourrage │   valeur    │unite│ bourrage │6       └─────┴───────────┴─────────────┴─────┴──────────┘7         1        3            4          1       3        = 12 octets

Trois octets sont perdus avant valeur, pour que l'entier commence à l'adresse 4. Trois de plus à la fin, pour que la taille totale soit un multiple de l'alignement le plus contraignant — sans quoi le deuxième élément d'un tableau de Mesure serait mal aligné.

D'où la règle pratique : ranger les champs du plus grand au plus petit.

1struct Mesure { int valeur; char capteur; char unite; };   /* 8 octets */

Un tiers d'économie, sans rien changer d'autre. Sur un tableau d'un million d'enregistrements, c'est quatre mégaoctets — et autant de défauts de cache en moins, au sens du chapitre 7 d'architecture.

Conséquence à retenir pour la suite du chapitre : la taille d'une structure n'est pas la somme de ses champs, et sa disposition exacte dépend du compilateur et de la machine. C'est précisément ce qui rend l'écriture binaire non portable.

Fichiers

Un fichier se manipule par un flux, désigné par un FILE *.

1FILE *f = fopen("donnees.txt", "r");2if (f == NULL) { perror("donnees.txt"); return 1; }3/* … */4fclose(f);

Le test de NULL n'est pas optionnel : le fichier peut être absent, ou les droits du chapitre 7 du cours de systèmes peuvent l'interdire. perror affiche le message correspondant à l'erreur réelle, ce qui évite de deviner.

Le mode "w" mérite un avertissement : il efface le contenu existant à l'ouverture, avant même la première écriture. Une faute de frappe dans un nom de fichier détruit son contenu.

Deux familles de lecture et d'écriture.

En texte : fprintf et fscanf — les mêmes formats qu'au chapitre 2 —, fgets pour lire une ligne entière avec une taille maximale, et fputs. Le fichier reste lisible et éditable, et il est portable.

En binaire : fwrite et fread recopient les octets tels quels. C'est compact et rapide — écrire un tableau de structures tient en un appel — mais non portable : la taille des types, l'ordre des octets et le bourrage varient d'une machine à l'autre. Un fichier binaire écrit sur une machine peut être illisible sur une autre.

Le piège de la fin de fichier

C'est la faute la plus fréquente du chapitre, et elle produit une ligne en trop.

1while (!feof(f)) {                 /* FAUX */2    fscanf(f, "%d", &n);3    printf("%d\n", n);4}

feof ne prédit pas la fin : elle indique qu'une lecture a déjà échoué en l'atteignant. Au dernier tour, fscanf lit la dernière valeur sans que feof bascule ; la condition reste vraie, on entre une fois de plus, fscanf échoue et laisse n inchangé — donc la dernière valeur est affichée deux fois.

La forme correcte teste le retour de la lecture, qui est la seule information fiable :

1while (fscanf(f, "%d", &n) == 1) {2    printf("%d\n", n);3}

Même règle pour fgets, qui rend NULL en fin de fichier, et pour fread, qui rend le nombre d'éléments effectivement lus.

À vous

L'exercice a deux volets.

D'abord la disposition mémoire : vous écrivez le calcul du bourrage — alignement de chaque champ, puis alignement de la structure entière — et vous vérifiez sur trois structures que réordonner les champs change la taille. Vous retrouverez les 12 et les 8 du cours.

Ensuite un mini-format de fichier : écriture d'un tableau d'enregistrements en texte, relecture, et comparaison. Le squelette contient la boucle fautive avec feof ; vous constaterez la ligne dupliquée, puis vous écrirez la version correcte. Une dernière partie écrit les mêmes données en « binaire » — c'est-à-dire en recopiant la disposition mémoire calculée plus haut — et vous verrez ce qui se passe quand on les relit avec un autre ordre de champs : exactement ce qu'un changement de machine provoque.

// ── 1. Disposition mémoire et bourrage ────────────────────────────────────
const TAILLE = { char: 1, short: 2, int: 4, double: 8, pointeur: 8 };

// Un champ de k octets doit commencer à une adresse multiple de k.
function disposer(champs) {
  let decalage = 0, alignementMax = 1;
  const plan = [];
  for (const [nom, type] of champs) {
    const k = TAILLE[type];
    alignementMax = Math.max(alignementMax, k);
    // ← à écrire : avancer decalage jusqu'au prochain multiple de k,
    //   en notant le bourrage inséré
    plan.push({ nom, type, decalage, taille: k, bourrageAvant: 0 });
    decalage += k;
  }
  // ← et à la fin : la TAILLE TOTALE doit être un multiple de alignementMax
  return { plan, taille: decalage, alignementMax };
}

function montrer(nom, champs) {
  const d = disposer(champs);
  console.log("   " + nom + " -> sizeof = " + d.taille +
              " (somme des champs : " + champs.reduce((s, [, t]) => s + TAILLE[t], 0) + ")");
  for (const c of d.plan) {
    console.log("      offset " + String(c.decalage).padStart(2) + "  " + c.nom.padEnd(8) +
      c.type.padEnd(9) + (c.bourrageAvant ? "  (+" + c.bourrageAvant + " de bourrage avant)" : ""));
  }
}

// ── 2. Un mini-fichier texte ──────────────────────────────────────────────
function creerFichier(lignes) {
  let position = 0;
  return {
    // Rend la valeur lue, ou null en fin de fichier — comme fscanf rend 1 ou 0.
    lire() { return position < lignes.length ? lignes[position++] : null; },
    finAtteinte: () => position >= lignes.length,
    rembobiner() { position = 0; },
  };
}

// La boucle fautive du cours.
function lireAvecFeof(f) {
  const sortie = [];
  let n = "?";
  while (!f.finAtteinte()) {
    const lu = f.lire();
    if (lu !== null) n = lu;      // en C, un fscanf en échec NE TOUCHE PAS n
    sortie.push(n);
  }
  return sortie;
}

function lireCorrectement(f) {
  const sortie = [];
  // ← à écrire : tester le RETOUR de la lecture, pas la fin de fichier
  return sortie;
}

// ── À VOUS ────────────────────────────────────────────────────────────────
// 1. Écrivez disposer() et retrouvez les 12 puis les 8 octets du cours.
// 2. Écrivez lireCorrectement() et comparez les deux sorties.
// 3. Écrivez un enregistrement « en binaire » avec une disposition, relisez-le
//    avec une AUTRE disposition : c'est ce qu'un changement de machine fait.

montrer("Mesure  { char, int, char }", [["capteur", "char"], ["valeur", "int"], ["unite", "char"]]);

En travaux pratiques

Ce que la suite en fait

Le chapitre 10 clôt le cours par l'outillage, et les deux volets de ce chapitre y reviennent. gdb sait afficher une structure champ par champ — y compris le bourrage — ce qui est la façon la plus rapide de comprendre une disposition mémoire. Et les erreurs de fichier sont exactement le genre de faute que les assertions et un jeu de tests attrapent avant la mise en service.

À retenir