Fonctions

01 - Introduction 05 - Valeur de retour
02 - Définition 06 - Procédures
03 - Paramètres 07 - Exercices
04 - Appel de fonctions

01

Introduction

En Informatique, une fonction est un sous-programme, c.-à-d. une partie de code indépendante du reste du programme, et réalisant une certaine tâche. Cette partie de code est une séquence d'instructions qui détermine une sortie en fonction de l'entrée de la fonction. Schématiquement, on peut s'imaginer une fonction de la manière suivante:

schema_fonction.png

Lorsqu'on appelle une fonction, c.-à-d. lorsqu'on fait exécuter les instructions de la fonction, on peut transmettre des valeurs qu'elle utilisera pendant son exécution. Un appel de fonctions a donc trois éléments:

Pour mieux illustrer le fonctionnement des fonctions, prenons comme exemple concret la fonction triple, qui calcule le triple d'un nombre:

Schématiquement, cette fonction peut être représentée de la manière suivante:

fonction_triple.png

Lors de l'appel de la fonction, le programme appelant peut spécifier une valeur pour l'entrée et obtenir le résultat correspondant. Supposons que le programme transmet la valeur 20 à la fonction triple, le schéma est le suivant :

fonction_triple_20.png

02

Définition

Les définitions des fonctions sont généralement placées entre les déclarations de variables et le bloc principal. La forme générale d'une définition d'une fonction est la suivante:

function <nom de la fonction> (<déclaration des paramètres>) : <type de retour>;
<déclaration de variables>
begin
  <instruction 1>;
  <instruction 2>;
  ...
  <instruction n>;
end;

La définition d'une fonction commence toujours avec le mot-clé function suivi du nom de la fonction. Le nom de la fonction doit obligatoirement respecter les mêmes règles que les noms des variables, c.-à-d. il est admissible lorsqu'il commence par une lettre ou le blanc souligné « _ » (anglais : underscore) et peut être suivi d'une suite de symboles qui peuvent être des lettres, des chiffres ou le blanc souligné « _ ».

Entre les parenthèses, directement après le nom de la fonction, se trouve la déclaration des paramètres de la fonction. Les paramètres sont les valeurs d'entrée de la fonction. Pour plus d'informations, consultez le chapitre sur les paramètres.

Un double-point sépare la déclaration des paramètres et la définition du type de retour. Le type de retour est le type de la sortie de la fonction et correspond à un type de variable. Pour plus d'informations, consultez le chapitre sur la valeur de retour. La définition du type de retour est suivie d'un point-virgule.

Comme une fonction est un sous-programme indépendant du reste du programme, elle peut aussi déclarer ses propres variables. Tout comme les variables du programme principal, les variables d'une fonction sont déclarées dans un endroit spécifique qui est précédé du mot-clé var. Les déclarations se font de manière classique.

Le corps de la fonction est un bloc (partie délimitée par les mots-clés begin et end) contenant une séquence d'instructions qui peuvent être les mêmes que dans le bloc principal avec une seule exception : la fonction peut définir la valeur de retour de la fonction, c.-à-d. la sortie de la fonction. Pour plus d'informations, consultez le chapitre sur la valeur de retour. Contrairement au bloc principal qui est suivi d'un point, le bloc d'une fonction est suivi d'un point-virgule.

En mettant toutes ces informations ensemble, on peut maintenant définir la fonction triple de l'introduction :

Définition de la fonction triple
function triple(x : integer) : integer;
begin
  result := 3*x;
end;

Une fois une fonction définie, on peut l'utiliser depuis le programme principal (ou depuis une autre fonction) en spécifiant les valeurs d'entrée, c.-à-d. les valeurs des paramètres. Voici un programme complet qui demande à l'utilisateur un nombre entier et qui affiche le triple de ce nombre en utilisant la fonction triple.

Exemple complet avec la fonction triple
program exemple_triple;

{
 Le programme suivant demande un nombre entier à la console
 et affiche le triple de ce nombre en utilisant à cet effet
 la fonction triple définie auparavant.
}

var
  nbr : integer;

function triple(x : integer) : integer;
begin
  result := 3*x;
end;

begin
  write('Entrez un nombre entier: ');
  readln(nbr);
  writeln('Le triple de ', nbr, ' est: ', triple(nbr));
  readln;
end.

03

Paramètres

Dans la définition d'une fonction intervient aussi la déclaration des paramètres. Les paramètres sont les valeurs avec lesquelles la fonction va travailler pendant son exécution et qui correspondent à l'entrée de la fonction.

Un paramètre n'est rien d'autre qu'une variable, qui existe seulement à l'intérieur de la fonction. Tout comme les variables, un paramètre a donc un nom et un type, qu'il faut déclarer à l'intérieur des parenthèses lors de la définition de la fonction. On peut aussi utiliser la notation simplifiée.

La plus grande différence entre les variables et les paramètres est que les paramètres sont initialisés automatiquement lors d'un appel de fonctions.

Analysons plusieurs exemples pour mieux comprendre le concept des paramètres. Lorsqu'on est demandé de définir une fonction, il faut d'abord déterminer les paramètres de cette fonction. Notre fonction triple calcule le triple d'un nombre entier : elle a un seul paramètre qui est du type integer. La définition de la fonction triple correspond donc au code suivant :

Définition de la fonction triple
function triple(x : integer) : integer;
begin
  { ... }
end;

Prenons un autre exemple : la fonction sum qui calcule la somme de deux nombres décimaux. Comme la fonction calcule la somme de deux nombres décimaux, elle doit recevoir la valeur de ces deux nombres en entrée : elle a donc deux paramètres qui sont du type real. La définition de la fonction sum correspond donc au code suivant :

Définition de la fonction sum
function sum(a, b : real) : real;
begin
  { ... }
end;

Le dernier exemple est la fonction findChar qui détermine si un caractère donné se trouve dans une chaîne de caractères donnée. Pour pouvoir réaliser cette tâche, la fonction nécessite bien sûr le caractère recherché ainsi que la chaîne de caractères dans laquelle on fait la recherche : elle a donc un paramètre de type char et un paramètre de type string. Le définition de la fonction findChar correspond donc au code suivant :

Définition de la fonction findChar
function findChar(c : char; s : string) : boolean;
begin
  { ... }
end;

Nous pouvons aussi définir une fonction qui n'a pas de paramètres:

Définition d'une fonction sans paramètres
function pi() : real;
begin
  result := 3.14159;
end;

Des informations supplémentaires sur les paramètres et le passage des arguments se trouvent dans l'article paramètres.

04

Appel de fonctions

Un appel de fonctions est l'exécution des instructions de la fonction en spécifiant les valeurs des paramètres de la fonction. Pour faire appel à une fonction, il faut spécifier le nom de la fonction suivi des valeurs des paramètres, séparées par des virgules, entre parenthèses. Les valeurs qui sont attribuées aux paramètres sont appelées les arguments.

Voici un exemple d'un appel de la fonction triple avec comme argument 20:

Appel de la fonction triple
program exemple_triple;

function triple(x : integer) : integer;
begin
  result := 3*x;
end;

begin
  writeln('Le triple de 20 est: ', triple(20));
  readln;
end.

Si on fait appel à une fonction qui ne prend pas d'arguments, alors les parenthèses ne sont pas obligatoires. Cependant, je conseille de toujours les mettre pour ne pas confondre les appels de fonction avec les variables :

Calcul de l'aire d'un disque (1)
program aire_disque;

{
 Le programme suivant demande le rayon d'un disque à la console
 et calcule et affiche l'aire de ce disque.
}

var
  rayon : real;

function pi() : real;
begin
  result := 3.14159;
end;

begin
  write('Entrez le rayon du disque: ');
  readln(rayon);
  writeln('L''aire du disque de rayon ', rayon:0:2, ' est: ', pi()*rayon*rayon);
  readln;
end.

Même exemple mais avec une approche encore plus structurée:

Calcul de l'aire d'un disque (2)
program aire_disque;

{
 Le programme suivant demande le rayon d'un disque à la console
 et calcule et affiche l'aire de ce disque.
}

var
  rayon : real;

function pi() : real;
begin
  result := 3.14159;
end;

function aire_disque(r : real) : real;
begin
  result := pi()*r*r;
end;

begin
  write('Entrez le rayon du disque: ');
  readln(rayon);
  writeln('L''aire du disque de rayon ', rayon:0:2, ' est: ', aire_disque(rayon));
  readln;
end.

Lors d'un appel de fonctions, l'ordinateur mémorise l'endroit où la fonction a été appelée et exécute les instructions de la fonction. Lorsque l'exécution de la fonction a terminée et l'ordinateur a déterminé la valeur de retour de la fonction, il revient à l'endroit où l'appel a été fait et « remplace » l'appel de fonctions par la valeur déterminée. Ensuite il continue l'exécution de l'instruction ayant fait l'appel.

05

Valeur de retour

Chaque fonction a une valeur de retour, qui est la valeur par laquelle un appel de fonctions est remplacé une fois que la fonction a terminé son exécution. La valeur de retour correspond à la sortie de la fonction et est la valeur résultante de l'exécution des instructions de la fonction.

La valeur de retour d'une fonction a toujours un certain type, qui s'appelle le type de retour et qu'il faut spécifier lors de la définition d'une fonction. La fonction triple par exemple, qui calcule le triple d'un nombre entier, a donc comme type de retour aussi un nombre entier. La fonction sum, qui calcule la somme de deux nombres décimaux, a donc comme type de retour aussi un nombre décimal. Finalement, la fonction findChar, qui détermine si un caractère donné se trouve dans une chaîne de caractères donnée, a comme type de retour une valeur vrai/faux, qui est donc un boolean.

Pour spécifier la valeur de retour, chaque fonction dispose d'une variable prédéfinie (il ne faut donc pas la déclarer explicitement), qui s'appelle result. Le type de la variable result est le type de retour de la fonction. La variable result se comporte comme une variable standard c.-à-d. on peut l'initialiser, lui affecter une valeur et lire sa valeur. La plus grande différence entre la variable result et une variable ordinaire et que l'appel de fonctions est remplacé par la valeur de result après l'exécution de la fonction.

Voici donc un exemple complet avec la fonction findChar, qui détermine si un caractère donné se trouve dans une chaîne de caractères donnée.

Exemple complet avec la fonction findChar
program exemple_findChar;

var
  lettre : char;
  mot : string;

function findChar(c : char; s : string) : boolean;
var
  i : integer;

begin
  result := false;
  for i := 1 to length(s) do
    if (s[i] = c) then
      result := true;
end;

begin
  write('Veuillez entrez un mot: ');
  readln(mot);
  write('Veuillez entrez une lettre: ');
  readln(lettre);
  if (findChar(lettre, mot)) then
    writeln('La lettre ''', lettre, ''' se trouve dans le mot ''', mot, '''')
  else
    writeln('La lettre ''', lettre, ''' ne se trouve pas dans le mot ''', mot, '''');
  readln;
end.

06

Procédures

Bien que la plupart des livres et support de cours fassent une claire distinction entre fonctions et procédures, on peut résumer le concept de procédures en une seule phrase :

Une procédure est une fonction que ne retourne pas de valeur.

Les conséquences sont donc les suivantes :

La forme générale d'une procédure est donc la suivante :

procedure <nom de la procédure> (<déclaration des paramètres>);
<déclaration de variables>
begin
  <instruction 1>;
  <instruction 2>;
  ...
  <instruction n>;
end;

07

Exercices

Sign In