Fonctions et modularité

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)