L'appel de sous-programmes

Intutivement, on peut voir un sous-programme comme une boîte noire qui définit une série des tâches à réaliser sur des paramètres ``virtuels''. Chaque fois que l'on désire éffectuer les tâches en question, on doit donner des paramètres ``réels'' (effectifs) à la boîte lors de son appel ou invocation. Les tâches sont alors executées sur ces paramètres effectifs.

$parametre_1 \$ --> $parametre_2 \$ --> ...

Sous-programme tâches sur les paramètres..

$\verb*~==>~ \;$ Résultat ou Effet

Il y a deux sortes de sous-programmes: les procédures et les fonctions:

• fonction: en fin d'exécution produit une valeur résultat,
• procédure: ne renvoie pas de valeur, mais produit des effets: l'état de la machine change.

La syntaxe d'un appel est:
Nom_sous_programme ( parametre₁, parametre₂, $\ldots$)

Exemple:
racine(3,8) appel de fonction pour calculer $\sqrt[3]{8}$,

put(``Bonjour'') appel de procédure pour afficher Bonjour.

Ces invocations sont réalisées au milieu de programmes qui éffectuent d'autres tâches.

x:= racine(3,8) + carre(2) - 3;
put(``Bonjour''); put(``Voici la valeur de x: ``); put(x);

L'utilisation d'un sous-programme suppose:

• Il existe quelque part une description du sous-programme avec:
  • les paramètres ``virtuels'' (dits formels) qu'il attend à chaque invocation,
  • les tâches à réaliser sûr eux,
  • la nature du sous-programme (fonction ou procédure), et les cas écheant, le moyen de calculer la valeur qui doit être rendue en résultat.

• le programme où apparaît l'invocation doit:
  • connaître l'endroit où cette description est faite,
  • ``brancher'' les paramètres de l'appel (paramètres effectifs) aux paramètres virtuels (formels),
  • déclencher l'exécution du sous-programme et ``collecter'' les cas écheant son résultat,
  • resumer l'exécution du programme au point où l'on l'avait laissé lors de l'invocation du sous-programme, en utilisant le résultat éventuellement obtenu.

Pendant l'exécution, le fait de passer d'un point à un autre du programme, est aussi appelé, passer le contrôle (d'un point à un autre) dans le programme.

Exemple:

  x := 2 + 3;
  x := 3 + carre(x) + 2;
          ^        ^
          |        |
  point d'appel    point de retour avec 25

L'exécution se passe ainsi:

• on évalue 2 + 3 puis on affecte sa valeur à x: x <- 5,
• on appele la fonction carre en lui donnant 5 en argument:

  • le contrôle du programme est donné aux actions dans la fonction,
  • le calcul 5² est éffectué,

  • le contrôle du programme revient au point de retour dans le code appelant, avec la valeur résultat 25.