Une comparaison attentive des deux fonctions d'intégration précédemment réalisées nous montre une identité presque parfaite.
En effet, l'algorithme est strictement le même dans les deux cas : seule la fonction mathématique invoquée diffère.
Il serait dont souhaitable d'avoir un unique algorithme recevant en paramètre la fonction mathématique à intégrer.

Le langage C propose justement des types permettant de désigner des fonctions à l'aide de variables : les pointeurs sur fonctions.
Seulement, toutes les fonctions ne sont pas interchangeables : seules le sont celles qui ont des prototypes identiques, c'est la raison pour laquelle un type de pointeur sur fonctions spécifie très précisément le prototype des fonctions qu'il peut désigner.
(https://en.cppreference.com/w/c/language/pointer#Pointers_to_functions)

Dans le cas de notre exemple, nous traitons de fonctions mathématiques simples.
De telles fonctions attendent un paramètre réel et fournissent un résultat réel ; elles ont donc un prototype semblable à : Pour déclarer une variable de type pointeur sur de telles fonctions, la notation est la suivante : Contrairement aux déclarations de variables de types simples (comme int ou double), le nom de la variable ne suit pas le nom du type mais apparaît en son milieu.
Par rapport au prototype des fonctions, nous constatons que nous substituons simplement le nom_de_la_fonction par la notation (*nom_de_la_variable) (les parenthèses et l'étoile doivent obligatoirement apparaître comme indiqué).
De part et d'autre nous retrouvons les paramètres et le type de retour comme dans le cas du prototype d'une fonction.

Comme tout autre pointeur (voir cette section), une telle variable de type pointeur sur fonctions doit être initialisée pour désigner une information utile (une fonction ici) ou bien pour signifier très clairement qu'elle ne désigne rien (pointeur nul). Sur ces exemples d'initialisation, nous constatons que le nom d'une fonction (sans les parenthèses qui en matérialisent l'appel, afin de transmettre les éventuels paramètres) correspond à l'adresse de cette fonction✍ ; c'est cette information qui est mémorisée dans un pointeur sur fonctions.

Un pointeur sur fonctions est un pointeur comme un autre : il peut être affecté, passé en paramètre à une fonction, renvoyé comme résultat d'une fonction, comparé à un autre pour déterminer s'il est identique... seules l'indexation et l'arithmétique ne s'y appliquent pas.
Bien entendu lorsqu'un pointeur sur fonctions est recopié, il doit l'être vers un pointeur sur fonctions correspondant au même prototype (de la même façon qu'un pointeur sur entiers ne peut pas être implicitement converti vers un pointeur sur réels).
Il est éventuellement possible d'utiliser un cast vers un pointeur sur fonctions correspondant à un autre prototype mais il est extrêmement probable que cela conduise à un comportement indéfini du programme.

L'intérêt essentiel de mémoriser l'adresse d'une fonction dans un tel pointeur est de pouvoir invoquer ultérieurement cette même fonction en utilisant le pointeur qui aura été transmis à une partie du programme qui en a besoin. Nous constatons qu'invoquer une fonction via un pointeur qui la désigne utilise exactement la même notation qu'un appel de fonction habituel✍.

Revenons maintenant à notre problème d'intégration de fonctions mathématiques pour ajouter au module integrate une fonction Integrate_math() très semblable aux deux précédentes (qui seront conservées uniquement pour mémoire désormais). Elle attend un paramètre supplémentaire pour désigner la fonction mathématique à appeler.
Son algorithme fait simplement usage de ce pointeur sur fonctions en lieu et place des appels à sqrt() ou log() utilisés jusqu'alors.

Il faut ajouter à la fonction test_Integrate_math() du programme principal deux appels à cette nouvelle fonction sur le même intervalle que pour les tests précédents en leur transmettant respectivement l'adresse des fonctions sqrt() et log(). Après une nouvelle fabrication du programme exécutable et sa relance, vérifiez que les résultats produits par ces deux invocations du traitement générique sont bien identiques à ceux précédemment obtenus avec les traitements spécifiques.

Nous avons utilisé ici des fonctions mathématiques déjà fournies en standard mais rien ne nous empêche d'en utiliser de toutes autres du moment qu'elles respectent le prototype choisi pour le pointeur sur fonctions retenu. Complétez alors le programme principal avec cette fonction unitGaussian(). Elle aussi attend un paramètre réel et renvoie un résultat réel.
Elle utilisera la formule suivante :

Il s'agit d'une distribution gaussienne dans laquelle μ et σ sont des paramètres représentant respectivement la moyenne et l'écart-type.
(https://en.wikipedia.org/wiki/Normal_distribution)
Dans unitGaussian() nous les fixons respectivement à 0.0 et 1.0 afin que l'unique paramètre de la fonction corresponde à la variable x de la formule.

Il faut alors ajouter à la fonction test_Integrate_math() du programme principal ce nouvel appel à la fonction Integrate_math(). La fonction unitGaussian() est ici intégrée sur l'intervalle [0.0;1.0].
Après une nouvelle fabrication du programme exécutable et sa relance, vous devriez être en mesure de vérifier que le résultat obtenu correspond bien aux 34.1 % attendus pour un unique écart-type après la moyenne sur une gaussienne.
(https://en.wikipedia.org/wiki/Standard_deviation)

Nous disposons dorénavant, avec la fonction Integrate_math(), d'un moyen générique d'évaluer l'intégrale d'une fonction mathématique quelconque.
Cependant, le seul paramètre attendu par la fonction mathématique est la variable selon laquelle l'intégration a lieu.
Si d'autres paramètres doivent être pris en compte dans cette fonction mathématique (moyenne et écart-type d'une gaussienne, amplitude, fréquence et phase d'une sinusoïde...) il est nécessaire de les fournir comme des constantes littérales dans le code de ces fonctions (c'est ce que nous avons fait dans unitGaussian()).
Néanmoins, si ces paramètres supplémentaires ne sont pas connus à la compilation mais découverts à l'exécution, leur expression littérale préalable sera rendue impossible.

Il nous faut donc étendre le prototype des fonctions mathématiques que nous souhaitons intégrer pour transmettre les paramètres requis.
Puisque ces fonctions seront appelées par la fonction générique d'intégration, cette dernière devra également en avoir connaissance afin de les transmettre à la fonction à intégrer.
Seulement, la fonction générique d'intégration ne peut connaître le nombre et le type de ces paramètres puisqu'ils peuvent être tout à fait différents d'une fonction mathématique à une autre✍.
Cette dernière remarque nous contraint à fournir à la fonction générique un moyen de transmettre “aveuglément” (sans en connaître les détails) l'ensemble des paramètres que la fonction appelée requiert.

Le type void * (déjà rencontré dans cette section) représente un pointeur vers une donnée de type quelconque.
Le seul usage que l'on puisse en faire directement est le transfert ou la mémorisation d'une adresse.
Néanmoins, une conversion explicite d'une telle adresse vers un pointeur sur un type connu permet à nouveau de faire usage de la donnée désignée.
C'est donc ce procédé qui servira à confier à la fonction générique l'adresse d'une donnée qu'elle transmettra aveuglément à la fonction qu'elle doit invoquer par le pointeur sur fonctions.
Les fonctions alors invoquées doivent donc désormais accepter également un paramètre supplémentaire de type void * et doivent savoir le convertir en un pointeur sur le type effectif de la donnée désignée afin d'en faire l'usage attendu (les paramètres supplémentaires de nos fonctions mathématiques ici).

Les fonctions mathématiques que nous souhaitons intégrer auront désormais le prototype suivant : Un pointeur sur fonctions correspondant devrait donc être déclaré comme ceci : Remarquez que les types des pointeurs sur fonctions sont de manière générale difficilement lisibles et que la situation s'aggrave lorsque le prototype se complexifie.
Il est alors d'usage très courant d'utiliser le mot-clef typedef (voir cette section) pour leur attribuer une fois pour toutes un nom lisible✍. Le nom_du_type inventé sera alors utilisé aussi simplement que le nom d'un type de base partout où il sera nécessaire (paramètre d'une fonction générique, membre d'une structure...).

La donnée désignée par le paramètre de type void * peut être quelconque : il peut s'agir d'un type de base ou d'un type élaboré, comme une structure, afin de transmettre plusieurs informations à la fois.
Pour revenir à notre cas applicatif, nous souhaitons maintenant paramétrer notre fonction gaussienne selon une moyenne et un écart-type.
Pour ce faire, nous définissons dans le programme principal un type de structure contenant ces deux paramètres et une fonction gaussian() semblable à unitGaussian() mais attendant un paramètre supplémentaire de type void *. La première opération de cette fonction consiste à considérer son paramètre de type void * comme un pointeur sur la structure contenant les paramètres afin d'en récupérer les valeurs.
Elle reprend alors les formules précédentes (voir plus haut) en considérant ces paramètres.

Le module integrate doit alors être complété par la définition d'un type ParamMathFnct correspondant à un pointeur sur fonctions ayant le nouveau prototype attendu. Nous ajouterons également nouvelle fonction Integrate_param() semblable à Integrate_math() mais faisant usage de ce nouveau type de pointeur sur fonctions. Elle dispose d'un paramètre void * supplémentaire qui est transmis, sans même savoir ce qu'il désigne, à chaque invocation de la fonction pointée.

La fonction test_Integrate_param() doit être ajoutée au programme principal. Ses deux paramètres permettent d'initialiser une structure servant à contenir les paramètres supplémentaires attendus par la fonction gaussian().
Il suffit alors d'invoquer la fonction Integrate_param() pour évaluer l'intégrale sur l'intervalle [0.0;1.0] de la fonction gaussian() en prenant en compte les paramètres de moyenne et d'écart-types choisis lors de l'exécution.
Il est indispensable que le type de la donnée désignée par le pointeur void * corresponde exactement à ce qui est attendu par la fonction qui en fera finalement usage après un cast✍.
La fonction principale doit enfin réaliser un premier appel à la fonction test_Integrate_param() avec les valeurs 0.0 et 1.0 comme moyenne et écart-type, puis un second appel avec 1.0 et 0.5 comme nouvelles valeurs.
Après une nouvelle fabrication du programme exécutable et sa relance, vous devriez être en mesure de vérifier que le résultat obtenu pour le premier de ces appels est identique à ce que nous obtenions avec unitGaussian() et que le résultat du second appel correspond bien aux 47.7 % attendus pour deux écarts-types avant la moyenne sur une gaussienne.
(https://en.wikipedia.org/wiki/Standard_deviation)

Nous disposons dorénavant, à travers les fonctions Integrate_math() et Integrate_param() de deux fonctions d'intégration génériques.
La première s'applique à des fonctions simples dont le seul paramètre est la variable d'intégration ; la seconde permet de prendre en compte des paramètres supplémentaires quelconques liés au contexte applicatif.