Fonction de rappel

Un article de Wikipédia, l'encyclopédie libre.
Cet article est une ébauche concernant l’informatique.
Vous pouvez partager vos connaissances en l’améliorant. (Comment ?).

En informatique, une fonction de rappel (callback en anglais) est une fonction qui est passée en argument à une autre fonction. Cette-dernière peut alors faire usage de cette fonction de rappel comme de n'importe quelle autre fonction, alors qu'elle ne la connait pas par avance.

Sommaire

[modifier] Principe

La technique de la fonction de rappel s'inspire du principe d'Hollywood où l'appelant laisse ses coordonnées pour pouvoir être rappelé par la suite. L'intérêt est le passage à un modèle évènementiel et modulaire.

[modifier] Illustration

Prenons l'exemple d'un programme contenant une partie Analyseur effectuant par exemple l'analyse lexicale d'un document. Supposons qu'une partie Traitement du programme, soit capable de compter les occurrences des mots qui lui sont transmis. Si Traitement se déclare en attente d'évènements émanant d'Analyseur pour chaque mot reconnu au moyen d'une fonction de rappel, alors le programme global permettra de compter les occurrences des mots du texte analysé. Or, la partie Analyseur ne gère pas spécifiquement le comptage des mots et ne dépend pas de Traitement. Elle peut donc être réutilisée pour une autre tâche comme le test de la présence de mots-clés.

Pseudo-code de l'Analyseur:

// Variable de type fonction stockant la fonction de rappel
fonction(mot) traiterMot;

// Affectation de la fonction de rappel
fixerFonctionTraitementMot(fonction(mot) f) {
  traiterMot <- f;
}

// Corps de l'analyseur
analyse() {
  ...
  traiterMot(mot);
  ...
}

Pseudo-code du Traitement :

// Définition de la fonction qui sera rappelée
nouvelleOccurrence(mot) {
  ...
}

Pseudo-code du programme principal :

// préparation du rappel et 
fixerFonctionTraitementMot(nouvelleOccurrence);

//appel de l'analyseur
analyse();

[modifier] Exemple

Nous recherchons le premier entier supérieur à 5. (en langage C)


La première approche sans fonction de rappel:

int i;
 
 for (i = 0; i < length; i++)
 {
     if (array[i] > 5) 
     { 
         break;
     }
 }
 
 if (i < length) 
 {
     printf("Item %d\n", i);
 }
 else
 {
     printf("Not found\n");
 }

La seconde avec fonction de rappel:

/* LIBRARY CODE */
 int traverseWith(int array[], size_t length, 
                  int (*callback)(int index, int item, void *param), 
                  void *param)
 {
     int exitCode = 0;
     for (int i = 0; i < length; i++) {
         exitCode = callback(i, array[i], param);
         if (exitCode != 0) { 
             break;
         }
     }
     return exitCode;
 }
 
 /* APPLICATION CODE */
 int search (int index, int item, void *param)
 {
     if (item > 5) {
         *(int *)param = index;
         return 1;
     } else {
         return 0;
     }
 }
 
 /* (in another function) */
 int index;
 int found;
 found = traverseWith(array, length, &search, &index);
 if (found) {
     printf("Item %d\n", index);
 } else {
     printf("Not found\n");
 }

[modifier] Mise en oeuvre par passage de fonctions en paramètre

Les fonctions de rappel ont été très utilisées en programmation système et notamment en langage langage C. En effet, le C a permis assez tôt de passer des pointeurs de fonctions en paramètre d'autres fonctions. Cela le rendait techniquement capable d'implanter le mécanisme des fonctions de rappel.

Le passage de fonction en paramètre est généralisé en programmation fonctionnelle. Toutefois dans ce cadre, on ne parle plus de fonction de rappel. Dans ce paradigme, les fonctions sont des éléments de première classe (au même titre que les constantes par exemple). Aussi, les fonctions qui peuvent prendre d'autres fonctions en argument et/ou renvoyer une fonction comme valeur de retour sont alors qualifiées de fonctions d'ordre supérieur.

[modifier] Evolution du principe

Avec l'apparition de la programmation objet et des interfaces, la technique de rappel a évolué. On passe maintenant en paramètre un objet qui se conforme à une interface donnée. Il n'y a donc plus une, mais autant de fonctions que l'on souhaite rappeler. De plus le fait de passer un objet permet de contextualiser en indiquant sur quoi s'effectue le rappel, tandis qu'une fonction de rappel précisait seulement comment rappeler. Cependant la technique des fonction de rappel continue à avoir les faveurs des langages disposant de fermetures, où celles-ci offrent des capacités équivalentes aux objets en terme de contexte.

[modifier] Voir aussi