Le passage par valeur

En général, deux fonctions sont en jeu dans un appel de fonction : la fonction appelante et la fonction appelée. La fonction appelante évalue un appel de fonction, c'est-à-dire une expression formée à partir du nom de la fonction appelée et d'une liste d'arguments placés entre << ( >> et << ) >>, par exemple pgcd(6,15). Le nombre des arguments (dans l'appel) et le nombre des paramètres (dans la définition de la fonction) doivent être identiques : un appel à pgcd(6) est illégal. Le type d'un argument doit être égal au type du paramètre correspondant, ou dans certains cas, seulement compatible ; ainsi, si les types de l'argument et du paramètre correspondant sont numériques, une conversion implicite de l'argument vers le type du paramètre est effectuée, alors que les types déclarés sont distincts.

L'évaluation d'un appel de fonction commence par l'évaluation de ses arguments. Il y a en C++ deux modes de passage d'argument : par valeur et par référence. Nous ne traiterons pour commencer que le mode de passage par valeur (qui est l'unique mode de C). Par exemple, dans une fonction principale contenant les définitions

  int a = 6, b = 9;
  int d = pgcd(a, a+b);

les arguments a et a+b sont d'abord évalués à 6 et 15. Il y a ensuite invocation de la fonction appelée. On représentera une invocation par le symbole $\to$ : main() $\to$ pgcd(6,15). Il y a alors création en mémoire d'un bloc d'activation de la fonction appelée, qui a pour but l'exécution du corps de cette fonction, et dont le contenu sera détaillé un peu plus loin.

Quand l'exécution du corps de la fonction appelée est terminée, la fonction appelée retourne à la fonction appelante. Si le type du résultat de la fonction appelée est différent de void, la fonction retourne une valeur (une fonction peut retourner une valeur d'un type de base, d'un enum, d'un struct, d'un pointeur, ou encore une référence, mais ne peut pas retourner une fonction ou un tableau). La valeur retournée est celle de l'expression figurant dans l'instruction return exécutée (le corps de la fonction peut contenir plusieurs return, mais une seule sera exécutée, puisque la fonction retourne aussitôt après). Le type de cette expression doit être compatible avec le type de retour de la fonction ; si ces types sont numériques, il y a conversion implicite de la valeur de l'expression de retour vers le type de retour : par exemple un << return 3; >> dans une fonction déclarée retourner un double ne retournera pas l'entier 3, mais le double $3.0$. On notera le retour d'une valeur $v$ a la fonction appelée par le symbole $\stackrel{v}{\to}$ ou par $\stackrel{v}{\gets}$ : pgcd(6,15) $\stackrel{3}{\to}$ main(), ou main() $\stackrel{3}{\gets}$ pgcd(6,15).

Une procédure, c'est-à-dire une fonction dont le type du résultat est void, retourne à l'appelante, mais ne retourne pas de valeur⁷.

Un bloc d'activation a, comme les autres objets du programme, une existence en mémoire et une durée de vie. La zone mémoire qui lui est attribuée comporte, entre autres, les objets suivants :

• les paramètres, initialisés par la valeur des arguments
• les objets (variables, tableaux, etc) locaux
• l'objet valeur de retour, qui est initialisé par la valeur de l'expression $E$ quand une instruction << return $E$; >> est exécutée par la fonction appelée
• l'objet adresse de retour, c'est-à-dire l'adresse, dans le code de la fonction appelante, de l'instruction qui sera exécutée par celle-ci juste après le retour de l'appelée

Ce bloc est placé dans une partie de la mémoire appelée la pile. La durée de vie de ce bloc est l'exécution du corps de la fonction : il est empilé à l'invocation, et dépilé au retour. Ce mode d'allocation est appelé allocation automatique, ou allocation sur la pile ; la plupart des langages disposent de ce mode d'allocation, à l'exception notable de Fortran 77.

Cette description des opérations réalisées lors de l'appel d'une fonction spécifie la relation entre argument (d'appel) et paramètre (de définition), qui est ici le passage par valeur des arguments : pour chaque paramètre d'une fonction, et pour chaque invocation, il y a création d'une variable locale dans son bloc d'activation et initialisation de cette variable locale par la valeur de l'argument correspondant.

Les affectations à un paramètre ne peuvent donc pas modifier la valeur de l'argument correspondant. Il faudra procéder autrement si l'on souhaite réellement faire modifier la valeur d'une variable par une fonction, ce sera le passage par référence.