Passage de Paramètres : Valeur vs Référence

1. Le Passage par Valeur : La "Photocopie"

Le passage par valeur est le mécanisme le plus courant et le plus sûr.

Le principe : Quand vous passez une variable à une fonction "par valeur", le système ne transmet pas la variable elle-même, mais une copie de sa valeur. La fonction travaille alors sur cette copie, qui est une variable locale comme les autres. Toute modification apportée à cette copie à l'intérieur de la fonction n'a aucun impact sur la variable originale dans le programme qui a fait l'appel.

Analogie : C'est comme si vous me donniez une photocopie d'un document important. Je peux écrire, dessiner ou raturer ma copie autant que je veux, votre document original restera intact.

Pour formaliser cela, nous allons nous appuyer sur un document de cours.

Analysons l'exemple Algorithme C du document.

Pseudo-code :

Algorithme C

Var x : entier // Variable globale

Procédure Modif(x : entier) // 'x' est un paramètre local (passé par valeur)
Début
  x ← x + 1 // On modifie la COPIE de x
Fin

Début // Algorithme principal
  x ← 1
  Ecrire("Valeur de x avant l’appel : ", x) // Affiche 1

  Modif(x) // On passe une copie de la valeur de x (qui est 1)

  Ecrire("Valeur de x après l’appel : ", x) // Affiche TOUJOURS 1
Fin

Déroulement :

1. Dans le programme principal, la variable globale x est créée et initialisée à 1.
2. L'appel Modif(x) est exécuté.
3. Une nouvelle variable locale à la procédure Modif, qui s'appelle aussi x, est créée.
4. La valeur de la variable globale x (c'est-à-dire 1) est copiée dans cette nouvelle variable locale.
5. À l'intérieur de Modif, l'instruction x ← x + 1 s'applique à la variable locale. Sa valeur devient 2. La variable globale reste inchangée à 1.
6. La procédure Modif se termine. Toutes ses variables locales, y compris son paramètre x, sont détruites.
7. De retour dans le programme principal, Ecrire affiche la valeur de la variable globale x, qui n'a jamais été modifiée : 1.

Le passage par valeur est donc un mécanisme de protection. Il garantit qu'une fonction ne peut pas produire d'effets de bord en modifiant les variables du programme appelant.

2. Le Passage par Référence : L'"Adresse"

Parfois, nous voulons intentionnellement qu'une fonction modifie une variable. C'est là qu'intervient le passage par référence.

Le principe : Au lieu de passer une copie de la valeur, le système transmet une référence à la variable originale. On peut voir cette référence comme l'adresse mémoire de la variable. La fonction ne travaille donc plus sur une copie, mais directement sur la variable originale. Toute modification est donc répercutée à l'extérieur de la fonction.

Analogie : Cette fois, au lieu d'une photocopie, je vous donne l'adresse exacte (le numéro du tiroir et du dossier) où se trouve mon document original. Si vous allez à cette adresse et modifiez le document, c'est bien l'original qui est modifié.

L'image suivante illustre bien cette différence fondamentale.

Pour comprendre le fonctionnement en détail, nous allons utiliser une ressource qui schématise la mémoire.

Reprenons cet exemple d'échange de variables, qui est un cas d'usage parfait pour le passage par référence.

Pseudo-code :

// La mention 'en entrée/sortie' indique un passage par référence
Procédure Echange(a: entier en entrée/sortie, b: entier en entrée/sortie)
  Variables
    temp: entier
  Début
    temp ← a
    a ← b
    b ← temp
  Fin

Algorithme Principal
  Variables
    var1: entier
    var2: entier
  Début
    var1 ← 5
    var2 ← 10
    Ecrire("Avant : var1=", var1, ", var2=", var2) // Affiche 5, 10

    // On passe les variables elles-mêmes (leurs adresses)
    Echange(var1, var2)

    Ecrire("Après : var1=", var1, ", var2=", var2) // Affiche 10, 5
  Fin

Déroulement :

1. Dans le programme principal, var1 est 5 et var2 est 10.
2. L'appel Echange(var1, var2) est exécuté.
3. Le paramètre a de la procédure Echange devient une référence vers var1. Le paramètre b devient une référence vers var2.
4. À l'intérieur de Echange :
   • temp ← a : temp reçoit la valeur de var1 (via la référence a), donc temp vaut 5.
   • a ← b : la variable var1 (pointée par a) reçoit la valeur de var2 (pointée par b). var1 vaut maintenant 10.
   • b ← temp : la variable var2 (pointée par b) reçoit la valeur de temp. var2 vaut maintenant 5.
5. La procédure se termine. Les variables var1 et var2 ont été permutées.

3. Quand utiliser l'un ou l'autre ?

Le choix entre passage par valeur et par référence est une décision de conception importante qui influence la propreté de votre code.

En règle générale, pour un code propre et facile à déboguer :

• Privilégiez le passage par valeur autant que possible.
• Utilisez le passage par référence uniquement lorsque c'est nécessaire et justifié par la logique de votre algorithme.

4. À vous de jouer

Pour vérifier votre compréhension, analysez le petit algorithme ci-dessous et prédisez les valeurs finales de a et b.

// Passage par valeur
Procédure AjouteDix_Valeur(param_val: entier)
  Début
    param_val ← param_val + 10
    Ecrire("-> Dans AjouteDix_Valeur, le paramètre vaut : ", param_val)
  Fin

// Passage par référence
Procédure AjouteDix_Ref(param_ref: entier en entrée/sortie)
  Début
    param_ref ← param_ref + 10
    Ecrire("-> Dans AjouteDix_Ref, le paramètre vaut : ", param_ref)
  Fin

Algorithme Principal
  Variables
    a: entier ← 100
    b: entier ← 100
  Début
    Ecrire("Initialement, a=", a, " et b=", b)

    AjouteDix_Valeur(a)
    AjouteDix_Ref(b)

    Ecrire("Finalement, a=", a, " et b=", b)
  Fin

Initialement, a=100 et b=100
-> Dans AjouteDix_Valeur, le paramètre vaut : 110
-> Dans AjouteDix_Ref, le paramètre vaut : 110
Finalement, a=100 et b=110

Conclusion

Aujourd'hui, nous avons décortiqué un mécanisme fondamental de la programmation : la manière dont les informations circulent entre les différentes parties d'un algorithme.

Points clés à retenir :

• Passage par valeur : C'est le mode "sécurisé". La fonction travaille sur une copie et ne peut pas altérer l'original. C'est le choix par défaut pour un code prévisible.
• Passage par référence : C'est le mode "puissant" qui donne à une fonction la permission de modifier la variable originale. Il est indispensable pour certaines tâches, comme l'échange de valeurs ou quand une procédure doit retourner plusieurs résultats.
• La maîtrise de ces deux modes vous donne un contrôle total sur le comportement de vos fonctions et les données de votre programme.

Et après ?

Maintenant que nous savons définir des fonctions, gérer la portée des variables et contrôler la manière dont elles communiquent via les paramètres, nous avons tous les outils en main pour nous attaquer à des problèmes plus ambitieux. Dans la prochaine leçon, nous apprendrons à décomposer un problème complexe en plusieurs fonctions modulaires, la pierre angulaire de la conception de programmes structurés, lisibles et faciles à maintenir.