Passage de fonctions en arguments

Fait partie de la section Object Oriented Programming du Journey C de Coddy — leçon 36 sur 61.

L'une des utilisations les plus puissantes des pointeurs de fonction consiste à les passer comme arguments à d'autres fonctions. Cela vous permet d'injecter un comportement personnalisé dans une fonction sans modifier son code — une technique parfois appelée un callback.

Considérez une fonction qui effectue un calcul sur deux nombres. Au lieu de coder l'opération en dur, vous pouvez accepter un pointeur de fonction qui définit l'opération à effectuer :

typedef int (*Operation)(int, int);

int compute(int a, int b, Operation op) {
    return op(a, b);
}

La fonction compute ne sait pas si elle additionne, soustrait ou fait tout autre chose. Elle appelle simplement la fonction qui lui est transmise :

int add(int a, int b) { return a + b; }
int multiply(int a, int b) { return a * b; }

int main() {
    printf("%d\n", compute(5, 3, add));       // Résultat : 8
    printf("%d\n", compute(5, 3, multiply));  // Résultat : 15
    return 0;
}

Remarquez comment la même fonction compute produit des résultats différents selon la fonction que nous passons. Ce modèle est fondamental pour écrire du code flexible et réutilisable — vous écrivez la structure une seule fois, et les utilisateurs de votre fonction fournissent la logique spécifique dont ils ont besoin.

Défi

Facile

Écrivez une fonction apply_twice qui prend deux entiers et un code d'opération, applique l'opération aux nombres deux fois de suite, et retourne le résultat final.

Votre fonction recevra un code d'opération qui détermine quelle opération utiliser. Vous devez définir les fonctions d'opération à l'intérieur de votre solution et les passer à une fonction auxiliaire compute qui accepte un pointeur de fonction.

Structure requise :

Définissez un typedef nommé Operation pour un pointeur de fonction qui prend deux paramètres int et retourne un int
Définissez deux fonctions d'opération : add (retourne a + b) et multiply (retourne a * b)
Définissez une fonction compute qui prend deux entiers et un pointeur de fonction Operation, puis retourne le résultat de l'appel de l'opération
Dans apply_twice, sélectionnez l'opération appropriée en fonction du code, puis utilisez compute deux fois : d'abord avec les nombres d'origine, puis avec le résultat et le deuxième nombre à nouveau

Logique :

Sélectionnez la fonction d'opération en fonction de op_code (1 = add, 2 = multiply)
Appelez compute(a, b, operation) pour obtenir un résultat intermédiaire
Appelez compute(intermediate, b, operation) pour obtenir le résultat final
Retournez le résultat final

Paramètres :

a (int) : Premier nombre
b (int) : Deuxième nombre
op_code (int) : Code d'opération (1 pour add, 2 pour multiply)

Retourne : Le résultat après avoir appliqué l'opération deux fois de suite (int)

Exemple : Avec a = 5, b = 3, op_code = 1 (add) :

Premier calcul : 5 + 3 = 8
Deuxième calcul : 8 + 3 = 11
Retourne : 11

Avec a = 2, b = 4, op_code = 2 (multiply) :

Premier calcul : 2 × 4 = 8
Deuxième calcul : 8 × 4 = 32
Retourne : 32

Aide-mémoire

Les pointeurs de fonction peuvent être passés comme arguments à d'autres fonctions, permettant des callbacks (rappels) — un moyen d'injecter un comportement personnalisé sans modifier le code de la fonction.

Définissez un type de pointeur de fonction en utilisant typedef :

typedef int (*Operation)(int, int);

Créez une fonction qui accepte un pointeur de fonction comme paramètre :

int compute(int a, int b, Operation op) {
    return op(a, b);
}

Passez différentes fonctions pour obtenir des comportements différents :

int add(int a, int b) { return a + b; }
int multiply(int a, int b) { return a * b; }

int main() {
    printf("%d\n", compute(5, 3, add));       // Résultat : 8
    printf("%d\n", compute(5, 3, multiply));  // Résultat : 15
    return 0;
}

Ce modèle vous permet d'écrire du code flexible et réutilisable où la structure est définie une seule fois et les utilisateurs fournissent la logique spécifique dont ils ont besoin.

Essayez vous-même

int apply_twice(int a, int b, int op_code) {
    // Écrire le code ici
}

Testez-vous

Cette leçon comprend un petit quiz. Commencez la leçon pour y répondre et suivre votre progression.

Toutes les leçons de Object Oriented Programming

1Bases de la programmation modulaire

Fichiers d'en-tête Gardes d'inclusion Fichiers sources Fonctions statiques Récapitulatif : Calculatrice modulaire

4Encapsulation

Concept des pointeurs opaques Définir des structures opaques Getters et setters Validation dans les setters Récapitulatif : La boîte secrète

7Pointeurs sur fonctions

Déclaration de pointeurs sur fonctions Appel de pointeurs sur fonctions Typedef pour les pointeurs sur fonctionsPassage de fonctions en argumentsRécapitulatif : Dispatcher de calculatrice

10Conteneurs génériques

Rappel sur les pointeurs void Wrapper générique Échange générique Comparaison générique Rappel : tableaux génériques

3Cycle de vie des objets

Pattern de constructeur Pattern de destructeur Initialisation sur la pile Copie profonde Récapitulatif : String Wrapper

6Héritage par composition

Imbrication de struct La règle du premier membre Accès aux membres parents Upcasting Récapitulatif : Hiérarchie des formes

9Projet : Dessinateur de formes

Aperçu du projet Implémentation du cercle

Implémentation du rectangle

Utilisation polymorphe

Conteneur de formes

12Défis finaux

Personnage de RPG Constructeur de chaînes dynamique Pile générique Système d'événements