Tutoriel de programmation C sous Linux Partie 25 - Pointeurs de fonction

Jusqu’à présent dans cette série de tutoriels de programmation C, nous avons discuté du concept de base des pointeurs ainsi que de plusieurs aspects liés aux pointeurs, comme le pointeur vers un tableau et le tableau de pointeurs. En approfondissant notre compréhension des pointeurs, dans ce tutoriel, nous allons discuter du concept des pointeurs vers des fonctions.

Pointeurs de fonction dans le langage de programmation C

Tout comme nous avons des pointeurs vers des variables, il peut également y avoir des pointeurs vers des fonctions. Voici un exemple de déclaration d’un pointeur de fonction :

void (*fn_ptr)(int)

Ici, nous avons un pointeur de fonction nommé ‘fn_ptr’ qui peut pointer vers n’importe quelle fonction qui retourne void et accepte un entier en entrée. Inutile de dire que ceci n’est que la partie déclaration - comme tout autre pointeur, vous devez lui assigner une adresse (celle d’une fonction dans ce cas) pour l’utiliser.

Voici un exemple utilisant ce pointeur :

#include   

void print_int(int a)  
{  
 printf("\n La valeur entière est : %d\n",a);  
}  
  
int main()  
{  
 void (*fn_ptr)(int);  
 fn_ptr = &print_int;  
 (*fn_ptr)(10);  
  
 return 0;  
}

Comme vous pouvez le voir, nous avons d’abord défini une fonction ‘print_int’ qui accepte un entier et retourne void. Ensuite, dans la fonction ‘main’, nous avons déclaré ‘fn_ptr’ comme un pointeur de fonction qui peut pointer vers des fonctions comme ‘print_int’. Cela a été suivi par l’assignation de l’adresse de la fonction ‘print_int’ à ‘fn_ptr’, et enfin, nous avons appelé la fonction en utilisant le pointeur.

Voici la sortie produite :

La valeur entière est : 10 

Il convient de mentionner ici que vous pouvez simplifier davantage ce programme en évitant & et * des deux dernières lignes. Voici le code modifié :

#include   

void print_int(int a)  
{  
 printf("\n La valeur entière est : %d\n",a);  
}  
  
int main()  
{  
 void (*fn_ptr)(int);  
 fn_ptr = print_int;  
 fn_ptr(10);  
  
 return 0;  
} 

En continuant, tout comme un tableau de pointeurs, vous pouvez également avoir un tableau de pointeurs de fonction. Par exemple, voici un tableau de pointeurs de fonction capable de stocker 3 adresses de fonction.

void (*fn_ptr[3])(int)

Et voici un exemple utilisant ce tableau de pointeurs :

void print_int1(int a)  
{  
 printf("\n La valeur entière est : %d\n",a);  
}  
  
void print_int2(int a)  
{  
 printf("\n La valeur entière est : %d\n",a+1);  
}  
  
void print_int3(int a)  
{  
 printf("\n La valeur entière est : %d\n",a+2);  
}  
  
int main()  
{  
 void (*fn_ptr[3])(int);  
   
 fn_ptr[0] = print_int1;  
 fn_ptr[1] = print_int2;  
 fn_ptr[2] = print_int3;  
   
 fn_ptr[0](10);  
 fn_ptr[1](10);  
 fn_ptr[2](10);  
  
 return 0;  
}

Voici la sortie produite par ce code :

La valeur entière est : 10   
   
La valeur entière est : 11   
   
La valeur entière est : 12

Un autre aspect des pointeurs de fonction que vous devriez connaître est que vous pouvez les utiliser comme arguments de fonction également. Par exemple, il peut y avoir une fonction qui accepte un pointeur vers une fonction comme argument. Par exemple :

void some_random_func(void (*fn_ptr)(int)) 

Voici un exemple de code qui utilise cette fonction :

#include   

void another_random_func(int a)  
{  
 printf("\n L'entier à entrer est : %d\n", a);  
}  
  
void some_random_func(void (*fn_ptr)(int))  
{  
 fn_ptr(5);  
}  
  
int main()  
{  
 some_random_func(another_random_func);  
 return 0;  
}

Ce que nous avons fait ici, c’est que nous avons créé une fonction appelée ‘some_random_func’ qui accepte un pointeur de fonction en entrée. Ensuite, depuis ‘main’, nous avons appelé ‘some_random_func’ avec l’adresse d’une autre fonction ‘another_random_func’ comme argument. Ensuite, en utilisant le pointeur, nous avons réussi à appeler ‘another_random_func’.

Voici la sortie :

L'entier à entrer est : 5 

Conclusion

Les pointeurs de fonction peuvent être utiles lorsque vous souhaitez créer quelque chose appelé un ‘mécanisme de rappel’ (lisez-en plus ici). Mais avant de vous plonger là-dedans, il est préférable que vous ayez une bonne compréhension de ce concept. Nous vous suggérons d’essayer les exemples de ce tutoriel sur votre machine locale (et aussi d’en créer de nouveaux). En cas de doute ou de question, laissez un commentaire ci-dessous.