Masar
Masar
Bac Tunisie
Informatique/SD-C
Entraîner la reconnaissance
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

  1. 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 ?
  2. La variable temp est-elle locale ou globale ? Quel est son rôle ?
  3. 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.

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.