SD-CStructures de données et modularité

Sous-programmes — fonctions, procédures, passage de paramètres, portée

Idée directrice

L'énoncé donne un programme décomposé en sous-programmes et demande de distinguer fonctions (retournent une valeur) et procédures (modifient via paramètres), d'identifier le mode de passage (par valeur vs par adresse/référence), et de déterminer la portée des variables (locales vs globales). La trace d'exécution doit montrer quelles variables sont modifiées.

Signature de reconnaissance — l'énoncé se trahit ainsi

« Expliquer la différence entre un passage de paramètre par valeur et par adresse » ; « Donner la valeur des variables après l'appel de la procédure … » ; « Identifier les variables locales et globales du programme » ; « Que faut-il modifier pour que la procédure … fonctionne correctement ? »

Sujet principal

Exercice — dans l'esprit des sujets du bac

3 questionsCorrigé masqué

On considère le programme suivant :

```
Variables globales : x, y : entier

Procédure Echanger(a : entier, var b : entier)
Variables temp : entier
Début
temp ← a ; a ← b ; b ← temp
Fin

Fonction Double(n : entier) : entier
Début
Retourner 2 * n
Fin

{ Programme principal }
Début
x ← 5 ; y ← 10
Echanger(x, y)
Écrire(x, y)
x ← Double(x)
Écrire(x)
Fin
```

Dans la procédure `Echanger`, expliquer la différence entre le paramètre `a` (par valeur) et le paramètre `b` (par adresse).
1. Donner les valeurs affichées par `Écrire(x, y)` après l'appel `Echanger(x, y)`. Justifier.
2. Pour que l'échange fonctionne correctement sur les deux variables, que faut-il modifier dans l'en-tête de la procédure ?
La variable `temp` est-elle locale ou globale ? Quel est son rôle ?
Donner la valeur affichée par le dernier `Écrire(x)` après `x ← Double(x)`, sachant que l'échange n'a pas modifié x.
1. Que se passe-t-il si l'on déclare `n` comme paramètre `var` dans `Double` et que l'on écrit `n ← 2*n` sans retourner ?

Voir la correction commentéeAprès avoir posé votre démarche

Passage par valeur vs adresse — trace d'exécution.

Instruction à exécuter et Valeur finale de la variable :

État initial : x ← 5 ; y ← 10.
Appel Echanger(x, y) avec signature `Echanger(a : entier, var b : entier)` : a reçoit une copie de x (=5) ; b est une référence à y.
Corps : temp ← a (=5) ; a ← b (=10) (seul le local a change) ; b ← temp (=5) → y devient 5. x n'est pas modifié.
Affichage Écrire(x, y) : x = 5, y = 5. L'échange est incomplet car x reste 5.

Puis x ← Double(x) : Double(n) calcule 2*n. On retourne 10 ; x contient la valeur 10. Affichage : 10.

Pour un échange complet : `DEF PROC Echanger(var a : entier ; var b : entier)` — les deux paramètres par adresse.

Rôle. Cette séquence permet de déterminer l'effet du mode de passage sur les variables appelantes : seul un paramètre `var` propage la modification. Q contient les couples (x,y) successifs : (5,10) → (5,5) → (10,5).

Portée : `temp` est local à Echanger (détruit à la fin de l'appel) ; x, y sont globaux dans le programme principal.

Exercices d'entraînement — une nuance à la fois

Entraînement 01 / 01

Drill SD-C.1 — fonction vs procédure

1 questionCorrigé masqué

Quelle est la différence entre une fonction et une procédure ? Donner un exemple d'usage de chacune.

Voir la correction commentéeAprès avoir posé votre démarche

Déclaration des objets (Type/Nature). Fonction : type de retour ; procédure : action sans retour.

```
DEF FN Carre(x : réel) : réel
Début
Retourner x * x
Fin
DEF PROC Afficher(T : tableau ; n : entier)
Variables i : entier
Début
Pour i de 1 à n faire Écrire(T[i]) FinPour
Fin
```

On retourne une valeur seulement pour la fonction ; i dans [1..n].

Méthode / Automatismes

Paramètre par valeur : copie locale → la variable appelante est inchangée après l'appel.
Paramètre par adresse (`var`) : alias → toute modification se répercute sur la variable appelante.
Fonction → retourne une valeur via `Retourner` ; procédure → modifie l'état via paramètres `var`.
Variable locale : déclarée dans le sous-programme, détruite à la fin de l'appel. Variable globale : accessible partout.
Portée : une variable locale cache une variable globale de même nom à l'intérieur du sous-programme.

Pièges classiques

Pièges fréquents : croire qu'un passage par valeur modifie la variable d'origine ; oublier `var` devant un paramètre qu'on veut modifier ; confondre variable globale et locale de même nom ; appeler une procédure comme si c'était une fonction (lui affecter une valeur de retour).

Variantes rencontrées : procédure de saisie avec paramètre `var` pour stocker le résultat ; fonctions avec plusieurs paramètres dont certains `var` ; analyse de portée dans des programmes imbriqués.