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.

Ce qui aide à reconnaître la démarche

« 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 ? »

Besoin d’un point de départ ? Voir la méthode

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.

Les pièges à vérifier dans ta démarche

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).

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.

2. Rôle de temp. temp est une variable locale à Echanger : elle naît à l'appel et disparaît au retour. Son rôle est de sauvegarder la valeur de a avant qu'elle ne soit écrasée par b, sans quoi l'une des deux valeurs serait perdue.

3.(a) var n dans Double. Si n est déclaré var et que l'on écrit n ← 2*n sans Retourner, c'est la variable effective x elle-même qui est doublée (passage par adresse) : x vaut 10 après l'appel, mais Double n'est plus une fonction (rien à retourner) et l'écriture x ← Double(x) devient incorrecte ; il faudrait l'appeler comme une procédure Double(x). Une fonction ne doit pas modifier ses arguments : on garde le passage par valeur et le Retourner.

Changer d’énoncé, garder le raisonnement

Choisis un seul transfert après le sujet principal. Qu’est-ce qui change ? Quel résultat ou quelle méthode peux-tu réutiliser ? Les autres exercices restent disponibles pour une prochaine séance.

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.

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

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

Entraînement 01 / 02

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].

2 Transfert — même corps, deux en-têtes : ce que le mode de passage change dans la trace et dans la validité des appels

Entraînement 02 / 02

Transfert — même corps, deux en-têtes : ce que le mode de passage change dans la trace et dans la validité des appels

4 questionsCorrigé masquéEn cours de relecture

On considère la procédure suivante et le programme principal qui l'appelle deux fois. Les objets globaux a et b sont des entiers.

Procédure Calcul (x : entier ; var y : entier)
Début
  x ← x + 1
  y ← y + x
  Écrire(x, y)
Fin

{ Programme principal }
Début
  a ← 3 ; b ← 5
  Calcul(a, b)
  Calcul(b, a)
  Écrire(a, b)
Fin

Compléter le tableau d'exécution donnant, après chaque instruction du programme principal, les valeurs de a et b, et pour chaque appel les valeurs de x et y à la sortie de la procédure. Indiquer les trois affichages produits.
Expliquer, appel par appel, pourquoi une des deux variables globales est modifiée et pas l'autre. En déduire le rôle de la procédure Calcul vis-à-vis de son second paramètre.
On remplace l'en-tête par Procédure Calcul (var x : entier ; var y : entier) sans toucher au corps. Donner les trois nouveaux affichages.
Avec l'en-tête d'origine, dire pour chacun des appels Calcul(a, 7), Calcul(2*a, b) et Calcul(a) s'il est valide ; justifier chaque appel invalide.

Cet exercice et sa correction sont en cours de relecture. Tu peux les consulter ; l’exercice n’est pas encore proposé en séance.

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

1. Idée : un paramètre par valeur travaille sur une copie, un paramètre var travaille sur la variable effective elle-même.

Instruction à exécuter	`a`	`b`	`x` (sortie)	`y` (sortie)	Affichage
`a ← 3 ; b ← 5`	3	5	—	—	—
`Calcul(a, b)`	3	9	4	9	`4 9`
`Calcul(b, a)`	13	9	10	13	`10 13`
`Écrire(a, b)`	13	9	—	—	`13 9`

Premier appel : x reçoit une copie de a (3) et devient 4 ; y désigne b, donc b ← 5 + 4 = 9. On retourne au programme principal avec a = 3, b = 9. Deuxième appel : x reçoit une copie de b (9) et devient 10 ; y désigne a, donc a ← 3 + 10 = 13. On retourne au programme principal avec a = 13, b = 9 : valeur finale de la variable a : 13 ; valeur finale de la variable b : 9. Les trois affichages sont $\boxed{4\ 9}$ , $\boxed{10\ 13}$ et $\boxed{13\ 9}$ .

2. Idée : la modification de x meurt avec la procédure, celle de y survit.

Dans Calcul(a, b), a est transmis par valeur : l'instruction x ← x + 1 modifie la copie locale, et a vaut toujours 3 après l'appel ; b est transmis par adresse (var), y et b sont la même case mémoire, donc b garde la valeur 9. Dans Calcul(b, a), les rôles s'échangent : c'est b qui est copié (il reste 9) et a qui est modifié (13). La procédure Calcul a donc pour rôle d'ajouter au second paramètre effectif le successeur du premier : y ← y + (x + 1), le premier paramètre servant seulement de donnée d'entrée.

3. Idée : si x devient var, l'incrémentation remonte aussi à la variable effective.

Calcul(a, b) : x désigne a, donc a ← 4 ; y désigne b, donc b ← 5 + 4 = 9 ; affichage 4 9 (inchangé, mais a vaut maintenant 4). Calcul(b, a) : x désigne b, donc b ← 9 + 1 = 10 ; y désigne a, donc a ← 4 + 10 = 14 ; affichage 10 14. Enfin Écrire(a, b) affiche 14 10. Les trois affichages deviennent $\boxed{4\ 9}$ , $\boxed{10\ 14}$ , $\boxed{14\ 10}$ : le second et le troisième diffèrent de la version d'origine parce que la modification de a par le premier appel est désormais conservée.

4. Idée : un paramètre effectif associé à un paramètre var doit être une variable ; le nombre et l'ordre doivent correspondre.

- Calcul(a, 7) : invalide. Le second paramètre formel y est passé par adresse : le paramètre effectif doit être une variable dont la procédure puisse modifier le contenu ; la constante 7 n'a pas d'adresse modifiable.
- Calcul(2*a, b) : valide. Le premier paramètre formel x est passé par valeur : une expression entière convient, sa valeur (6) est copiée dans x ; b est bien une variable entière pour y.
- Calcul(a) : invalide. Les paramètres effectifs et formels ne s'accordent pas en nombre (un fourni, deux attendus).

La validité d'un appel se juge donc sur trois critères à la fois : nombre, ordre et type des paramètres, plus la nature du paramètre effectif (variable obligatoire) quand le formel est var.

Relier ce raisonnement au bac

Choisis une filière pour voir les sujets qui étayent ce scénario.

Tu écris. Tu continues.

Où veux-tu aller ?

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

Exercice — dans l'esprit des sujets du bac

Changer d’énoncé, garder le raisonnement

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

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

Transfert — même corps, deux en-têtes : ce que le mode de passage change dans la trace et dans la validité des appels

Relier ce raisonnement au bac