Point de départ

// ── 1. La classe de bogue « goto fail » ───────────────────────────────────
// Un if sans accolades ne gouverne QUE l'instruction suivante.
function verifier(etapes) {
  let erreur = 0;
  for (const e of etapes) {
    if ((erreur = e.resultat) !== 0)
      return "ÉCHEC à l'étape " + e.nom;
      // ← quelqu'un a dupliqué la ligne ci-dessus lors d'une fusion.
      //   Ajoutez « return "ÉCHEC (ligne en trop)"; » ici et observez.
  }
  return "certificat valide";
}

// ── 2. Glissement de switch ───────────────────────────────────────────────
function menu(choix) {
  const sortie = [];
  switch (choix) {
    case 1:
      sortie.push("Ajouter");
      // ← break manquant
    case 2:
      sortie.push("Supprimer");
      break;
    case 3:
    case 4:
      sortie.push("Lister");   // glissement VOLONTAIRE : 3 et 4 font pareil
      break;
    default:
      sortie.push("Choix inconnu");
  }
  return sortie.join(" puis ");
}

// ── 3. Traduire le pseudocode d'Algorithmique 1 ───────────────────────────
// Pseudocode, indices de 1 à n :
//     max ← T[1]
//     Pour i de 2 à n Faire
//         Si T[i] > max Alors max ← T[i]
//
// Traduction en C, indices de 0 à n−1. Le tableau est instrumenté : tout
// accès hors bornes est enregistré au lieu de passer inaperçu.
function tableauSurveille(valeurs) {
  const hors = [];
  return {
    n: valeurs.length,
    lire(i) {
      if (i < 0 || i >= valeurs.length) { hors.push(i); return undefined; }
      return valeurs[i];
    },
    horsBornes: () => hors,
  };
}

function maximum(T) {
  let max = T.lire(1);          // ← traduction distraite de T[1]
  for (let i = 2; i <= T.n; i++) {
    if (T.lire(i) > max) max = T.lire(i);
  }
  return max;
}

// ── À VOUS ────────────────────────────────────────────────────────────────
// 1. Ajoutez la ligne en trop dans verifier() et constatez l'effet.
// 2. Complétez menu() pour que le choix 1 n'affiche que « Ajouter ».
// 3. Corrigez maximum() : bornes de 0 à n−1, avec un < strict. Vérifiez
//    qu'aucun accès hors bornes n'est enregistré.

const T = tableauSurveille([3, 17, 8, 42, 5]);
console.log("maximum :", maximum(T), "| hors bornes :", JSON.stringify(T.horsBornes()));

Solution

function verifierAvecBogue(etapes) {
  let erreur = 0;
  for (const e of etapes) {
    if ((erreur = e.resultat) !== 0)
      return "ÉCHEC à l'étape " + e.nom;
      return "ÉCHEC (ligne en trop)";   // hors du if : TOUJOURS exécutée
  }
  return "certificat valide";
}

function verifierCorrige(etapes) {
  let erreur = 0;
  for (const e of etapes) {
    // Les accolades coûtent deux caractères et suppriment la classe entière
    // de bogues : la ligne ajoutée est visiblement DANS le bloc, ou hors.
    if ((erreur = e.resultat) !== 0) {
      return "ÉCHEC à l'étape " + e.nom;
    }
  }
  return "certificat valide";
}

function menu(choix) {
  const sortie = [];
  switch (choix) {
    case 1:
      sortie.push("Ajouter");
      break;                     // le break qui manquait
    case 2:
      sortie.push("Supprimer");
      break;
    case 3:
    case 4:
      sortie.push("Lister");     // glissement volontaire, à commenter
      break;
    default:
      sortie.push("Choix inconnu");
  }
  return sortie.join(" puis ");
}

function tableauSurveille(valeurs) {
  const hors = [];
  return {
    n: valeurs.length,
    lire(i) {
      if (i < 0 || i >= valeurs.length) { hors.push(i); return undefined; }
      return valeurs[i];
    },
    horsBornes: () => hors,
  };
}

function maximumFaux(T) {
  let max = T.lire(1);
  for (let i = 2; i <= T.n; i++) if (T.lire(i) > max) max = T.lire(i);
  return max;
}

function maximumJuste(T) {
  // On ne traduit pas T[i] en T[i-1] : on RÉÉCRIT LES BORNES. L'idiome
  // « i = 0 ; i < n ; i++ » donne exactement n tours et des indices valides.
  let max = T.lire(0);
  for (let i = 1; i < T.n; i++) {
    const v = T.lire(i);
    if (v > max) max = v;
  }
  return max;
}

console.log("— 1. la ligne en trop —");
const etapes = [{ nom: "hachage", resultat: 0 }, { nom: "signature", resultat: 0 }];
console.log("   avec la ligne en trop :", verifierAvecBogue(etapes));
console.log("   avec les accolades    :", verifierCorrige(etapes));
console.log("   (le premier n'a vérifié AUCUNE étape : il sort au premier tour)");

console.log("");
console.log("— 2. switch —");
for (const c of [1, 2, 3, 4, 9]) console.log("   choix " + c + " -> " + menu(c));

console.log("");
console.log("— 3. traduction du pseudocode —");
const A = tableauSurveille([3, 17, 8, 42, 5]);
console.log("   version distraite : max =", maximumFaux(A),
            "| accès hors bornes :", JSON.stringify(A.horsBornes()));
const B = tableauSurveille([3, 17, 8, 42, 5]);
console.log("   version corrigée  : max =", maximumJuste(B),
            "| accès hors bornes :", JSON.stringify(B.horsBornes()));
// La version distraite lit T[5] — une case au-delà — et rate T[0]. Ici le
// maximum tombe juste par chance ; avec [42, 3, 17, 8, 5] elle rendrait 17.
const C = tableauSurveille([42, 3, 17, 8, 5]);
console.log("   sur [42,3,17,8,5] : distraite =", maximumFaux(C),
            " (le 42 en tête n'a jamais été lu)");
// En C, cet accès hors bornes ne provoque AUCUNE erreur : il lit l'octet
// suivant en mémoire. C'est le sujet du chapitre 5.

Avant de commencer

• Les TP 1 et 2

Énoncé

1. Le point-virgule — Écrivez une boucle qui compte de 1 à 10 en plaçant un point-virgule juste après la parenthèse fermante du for. Compilez avec -Wall et exécutez. Que se passe-t-il ?
2. L'affectation dans le test — Écrivez un si qui compare une variable à 5 en utilisant un seul signe égal. Exécutez. Puis trouvez l'écriture qui aurait fait échouer la compilation. Indice : Mettre la constante à gauche.
3. Le switch sans break — Écrivez un aiguillage à quatre cas sans aucun break. Exécutez avec chaque valeur et notez les sorties. Trouvez ensuite un cas où l'absence de break est VOULUE.
4. Le bloc manquant — Écrivez un si sans accolades suivi de deux instructions indentées identiquement. Exécutez, et expliquez pourquoi l'indentation vous a menti.
5. Boucle et condition composée — Écrivez une recherche dans un tableau qui s'arrête dès qu'elle trouve. Écrivez-la de trois façons : avec break, avec un drapeau, avec la condition dans le while. Comparez la lisibilité.
6. Au fil rouge — Ajoutez à journal le comptage des lignes contenant un mot donné, avec un rapport final. Testez sur un fichier vide, un fichier d'une ligne, et un gros fichier.

C'est réussi quand

• ✓ Vous savez expliquer sans exécuter ce qu'affiche une boucle terminée par un point-virgule
• ✓ Vous écrivez vos comparaisons de façon qu'un signe égal oublié ne compile pas
• ✓ Votre journal donne le bon compte sur un fichier vide

Correction

for (int i = 1; i <= 10; i++);      /* ← ce point-virgule */
  printf("%d ", i);

/* le corps de la boucle est l'instruction VIDE.
 Le printf est exécuté UNE fois, après la boucle —
 et ne compile même pas ici, car i n'existe plus. */

if (x = 5) …    /* AFFECTE 5 à x, puis teste 5, donc toujours VRAI */
if (x == 5) …   /* compare */

/* l'écriture qui protège : la constante à gauche */
if (5 == x) …   /* correct */
if (5 = x)  …   /* ERREUR de compilation : on ne peut affecter à 5 */

switch (n) {
case 1: printf("un ");
case 2: printf("deux ");
case 3: printf("trois ");
default: printf("fin\n");
}
n=1 → « un deux trois fin »    n=3 → « trois fin »

/* le cas où c'est VOULU */
switch (c) {
case 'a': case 'e': case 'i': case 'o': case 'u':
    voyelles++;
    break;
}

if (erreur)
  fprintf(stderr, "échec\n");
  return 1;              /* ← TOUJOURS exécuté */

/* le compilateur lit : */
if (erreur) fprintf(…);
return 1;

/* 1. break — la plus directe */
for (i = 0; i < n; i++) if (t[i] == cible) break;
if (i < n) …

/* 2. drapeau — verbeuse, mais parfois nécessaire */
int trouve = 0;
for (i = 0; i < n && !trouve; i++) if (t[i] == cible) trouve = 1;

/* 3. condition dans le while — la plus dense */
i = 0;
while (i < n && t[i] != cible) i++;

Point de départ

// ── 1. Les cadres d'appel, rendus visibles ────────────────────────────────
function cadre(nom, variables) {
  return { nom, variables };
}
function afficher(...cadres) {
  for (const c of cadres) {
    console.log("   " + c.nom.padEnd(10) +
      Object.entries(c.variables).map(([k, v]) => k + " = " + v).join("  |  "));
  }
}

// En C, appeler echanger(x, y) COPIE les valeurs dans de nouvelles cases.
function echangerParValeur(appelant) {
  const local = cadre("echanger", { a: appelant.variables.x, b: appelant.variables.y });
  console.log("   à l'entrée :");
  afficher(appelant, local);

  const t = local.variables.a;
  local.variables.a = local.variables.b;
  local.variables.b = t;

  console.log("   après l'échange des COPIES :");
  afficher(appelant, local);
  // le cadre local disparaît ici : rien n'est rendu à l'appelant
}

// ── 2. Portée et durée de vie ─────────────────────────────────────────────
// Une locale ordinaire est recréée à chaque appel.
function compteurLocal() {
  let n = 0;      // recréée, réinitialisée
  n++;
  return n;
}

// Une locale « static » survit d'un appel à l'autre. En JS on l'imite par
// une variable de portée englobante — ce qui montre bien la dissociation
// entre PORTÉE (le bloc) et DURÉE DE VIE (le programme).
const compteurStatic = (function () {
  let n = 0;      // ← allouée UNE fois, invisible de l'extérieur
  return function () { return 0; };   // ← à écrire
})();

// ── 3. Un mini-Makefile ───────────────────────────────────────────────────
const REGLES = {
  "programme": ["main.o", "pile.o"],
  "main.o": ["main.c", "pile.h"],
  "pile.o": ["pile.c", "pile.h"],
};

// dates[fichier] = horodatage de dernière modification
function aReconstruire(cible, dates, sortie = []) {
  const deps = REGLES[cible];
  if (!deps) return sortie;                    // un fichier source : rien à faire
  // ← à écrire : reconstruire d'abord les dépendances, puis la cible si
  //   l'une d'elles est plus récente qu'elle.
  return sortie;
}

// ── À VOUS ────────────────────────────────────────────────────────────────
// 1. Lancez l'échange et constatez que x et y n'ont pas bougé.
// 2. Écrivez compteurStatic, et comparez les deux compteurs sur trois appels.
// 3. Écrivez aReconstruire : après modification de pile.h, que faut-il
//    recompiler ? Et après modification de main.c seul ?

const principal = cadre("main", { x: 3, y: 7 });
echangerParValeur(principal);
console.log("   de retour dans main :");
afficher(principal);

Solution

function cadre(nom, variables) { return { nom, variables }; }
function afficher(...cadres) {
  for (const c of cadres) {
    console.log("   " + c.nom.padEnd(10) +
      Object.entries(c.variables).map(([k, v]) => k + " = " + v).join("  |  "));
  }
}

function echangerParValeur(appelant) {
  const local = cadre("echanger", { a: appelant.variables.x, b: appelant.variables.y });
  console.log("   à l'entrée :");
  afficher(appelant, local);
  const t = local.variables.a;
  local.variables.a = local.variables.b;
  local.variables.b = t;
  console.log("   après l'échange des COPIES :");
  afficher(appelant, local);
}

// La version qui marchera au chapitre 7 : on ne passe plus les valeurs mais
// de quoi ATTEINDRE les cases — ici l'objet du cadre et les noms.
function echangerParAdresse(appelant, nomA, nomB) {
  const t = appelant.variables[nomA];
  appelant.variables[nomA] = appelant.variables[nomB];
  appelant.variables[nomB] = t;
}

function compteurLocal() { let n = 0; n++; return n; }

const compteurStatic = (function () {
  // Allouée UNE fois, au chargement, et jamais réinitialisée. Son nom n'est
  // visible que d'ici : durée de vie du programme, portée du bloc.
  let n = 0;
  return function () { n++; return n; };
})();

const REGLES = {
  "programme": ["main.o", "pile.o"],
  "main.o": ["main.c", "pile.h"],
  "pile.o": ["pile.c", "pile.h"],
};

function aReconstruire(cible, dates, sortie = []) {
  const deps = REGLES[cible];
  if (!deps) return sortie;
  // D'abord les dépendances, en profondeur : une cible ne peut être jugée
  // à jour que si tout ce dont elle dépend l'est déjà.
  for (const d of deps) aReconstruire(d, dates, sortie);
  const dateCible = dates[cible] ?? -Infinity;
  const plusRecente = Math.max(...deps.map((d) => dates[d] ?? 0));
  if (plusRecente > dateCible) {
    sortie.push(cible);
    dates[cible] = plusRecente;   // la reconstruction la met à jour
  }
  return sortie;
}

console.log("— 1. passage par valeur —");
const principal = cadre("main", { x: 3, y: 7 });
echangerParValeur(principal);
console.log("   de retour dans main :");
afficher(principal);
console.log("   x et y n'ont pas bougé : les copies ont disparu avec le cadre.");
console.log("");
echangerParAdresse(principal, "x", "y");
console.log("   avec l'adresse (chapitre 7) :");
afficher(principal);

console.log("");
console.log("— 2. portée et durée de vie —");
for (let i = 1; i <= 3; i++) {
  console.log("   appel " + i + " : locale ordinaire = " + compteurLocal() +
              " | locale static = " + compteurStatic());
}
console.log("   La locale ordinaire est recréée à chaque appel ; la static est");
console.log("   allouée une fois, initialisée à zéro, et se souvient.");

console.log("");
console.log("— 3. mini-Makefile —");
for (const [quoi, dates] of [
  ["on modifie pile.h", { "main.c": 1, "pile.c": 1, "pile.h": 9, "main.o": 5, "pile.o": 5, "programme": 6 }],
  ["on modifie main.c seul", { "main.c": 9, "pile.c": 1, "pile.h": 1, "main.o": 5, "pile.o": 5, "programme": 6 }],
  ["rien n'a changé", { "main.c": 1, "pile.c": 1, "pile.h": 1, "main.o": 5, "pile.o": 5, "programme": 6 }],
]) {
  const r = aReconstruire("programme", { ...dates });
  console.log("   " + quoi.padEnd(24) + "-> " + (r.length ? r.join(", ") : "rien à faire"));
}
// Modifier un en-tête force la recompilation de tous les .o qui l'incluent :
// c'est pourquoi un .o doit DÉPENDRE des .h, faute de quoi make ne verrait
// rien et l'on déboguerait un binaire construit sur une interface périmée.

Avant de commencer

• Les TP 1 à 3
• Le fil rouge journal, en deux fichiers

Énoncé

1. La fonction qui ne marche pas — Écrivez une fonction echanger qui prend deux entiers et échange leurs valeurs. Appelez-la et affichez le résultat. Constatez l'échec, puis expliquez-le avec un schéma de la pile.
2. Portée et durée de vie — Écrivez une fonction avec une variable locale, la même en static, et une globale. Appelez la fonction trois fois et comparez les trois comportements.
3. Le pointeur qui pend — Écrivez une fonction qui renvoie l'adresse d'une variable locale. Compilez avec -Wall, lisez l'avertissement, exécutez quand même et expliquez ce qui se passe. Indice : L'espace de la variable est repris par l'appel suivant.
4. Découper le fil rouge — Réorganisez journal en trois modules : lecture, analyse, affichage. Chaque module a son en-tête. Aucune variable globale ne doit subsister.
5. Le contrat d'une fonction — Pour chaque fonction publique, écrivez au-dessus ce qu'elle attend, ce qu'elle rend, et ce qu'elle fait en cas d'erreur. Puis vérifiez que le code respecte ce que vous avez écrit.
6. Récursivité, en avant-goût — Écrivez la factorielle en récursif et en itératif. Faites-les tourner sur 20, puis sur 100000. Notez ce qui se passe dans le second cas.
7. Static au niveau fichier — Rendez privée une fonction utilitaire de votre module d'analyse. Tentez de l'appeler depuis main et lisez l'erreur.

C'est réussi quand

• ✓ Vous expliquez l'échec d'echanger sans employer le mot « bogue »
• ✓ Vos trois modules compilent séparément et aucune variable globale ne subsiste
• ✓ La factorielle récursive de 100000 échoue, et vous savez sur quelle ressource

Correction

void echanger(int a, int b) { int t = a; a = b; b = t; }

int x = 1, y = 2;
echanger(x, y);
printf("%d %d\n", x, y);   → 1 2  (inchangés)

pile :
main      : x=1     y=2
echanger  : a=1     b=2      ← des COPIES
après     : a=2     b=1      ← les copies sont échangées
retour    : les copies sont détruites, x et y n'ont jamais bougé

void f(void) {
  int         a = 0;   /* pile   : recréée à chaque appel */
  static int  b = 0;   /* statique : créée UNE fois, survit */
  a++; b++; g++;       /* g globale */
  printf("%d %d %d\n", a, b, g);
}
f(); f(); f();
→ 1 1 1
1 2 2
1 3 3

int *mauvais(void) {
  int local = 42;
  return &local;        /* warning: address of local variable returned */
}

int *p = mauvais();
autre_fonction();          /* réutilise le même espace de pile */
printf("%d\n", *p);       /* affiche n'importe quoi */

lecture.h    int   lire_lignes(const char *chemin, char ***lignes);
analyse.h    Stats analyser(char **lignes, int n);
affichage.h  void  afficher(const Stats *s);

main.c :
  char **lignes; 
  int n = lire_lignes(argv[1], &lignes);
  if (n < 0) return 1;
  Stats s = analyser(lignes, n);
  afficher(&s);

/* Lit toutes les lignes de « chemin ».
* Attend  : chemin non NULL, lignes non NULL.
* Rend    : le nombre de lignes, ou -1 en cas d'erreur.
* Alloue  : *lignes, à libérer par l'appelant avec liberer_lignes().
* En cas d'échec : *lignes n'est pas modifié. */
int lire_lignes(const char *chemin, char ***lignes);

factorielle(20)     → 2432902008176640000, correct
factorielle(100000) → Segmentation fault

100 000 appels imbriqués × ~48 octets de trame ≈ 4,8 Mo
pile par défaut : 8 Mo, mais chaque appel coûte aussi
l'adresse de retour et les registres sauvegardés

ulimit -s   → 8192 (Ko)