Contrôle du flux

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++;