Devrais-je utiliser std::function ou un pointeur de fonction en C++?

en bref, utilisez std::function sauf si vous avez une raison de ne pas le faire.

pointeurs de fonction ont l'inconvénient de ne pas être en mesure de capturer un certain contexte. Vous ne pourrez pas, par exemple, passer une fonction lambda comme un callback qui capture certaines variables de contexte (mais cela fonctionnera s'il n'en capture aucune). Appeler une variable membre d'un objet (c'est-à-dire non statique) n'est donc pas non plus possible, puisque l'objet ( this pointeur") doit être capturé. ⁽¹⁾

std::function (depuis c++11) est principalement à stocker une fonction (passer autour ne nécessite pas qu'il soit stocké). Par conséquent, si vous souhaitez stocker le rappel par exemple dans une variable membre, c'est probablement votre meilleur choix. Mais aussi si vous ne le stockez pas, c'est un bon "premier choix" bien qu'il ait l'inconvénient d'introduire certains (très petit) frais généraux quand être appelé (donc dans une situation très critique de performance, il peut être un problème, mais dans la plupart des cas, il ne devrait pas). Il est très "universel": si vous vous souciez beaucoup de cohérence et de lisibilité du code ainsi que si vous ne voulez pas penser à tous les choix que vous faites (c.-à-d. que vous voulez le garder simple), utilisez std::function pour chaque fonction que vous passez autour.

pensez à une troisième option: si vous êtes sur le point d'implémenter une petite fonction qui alors signale quelque chose via la fonction de rappel fournie, considérons un paramètre de modèle , qui peut alors être n'importe quel objet appelable , c.-à-d. un pointeur de fonction, un functor, un lambda, un std::function , ... L'inconvénient est que votre fonction (externe) devient un modèle et doit donc être implémentée dans l'en-tête. D'un autre côté, vous obtenez l'avantage que l'appel au callback peut être inlined, comme le code client de votre (outer) fonction "voit" l'appel au callback sera l'information de type exacte être disponible.

exemple pour la version avec le paramètre template (écrire & au lieu de && pour pré-C++11):

template <typename CallbackFunction>
void myFunction(..., CallbackFunction && callback) {
    ...
    callback(...);
    ...
}

comme vous pouvez le voir dans le tableau suivant, tous ont leurs avantages et inconvénients:

+-------------------+--------------+---------------+----------------+
|                   | function ptr | std::function | template param |
+===================+==============+===============+================+
| can capture       |    no(1)     |      yes      |       yes      |
| context variables |              |               |                |
+-------------------+--------------+---------------+----------------+
| no call overhead  |     yes      |       no      |       yes      |
| (see comments)    |              |               |                |
+-------------------+--------------+---------------+----------------+
| can be inlined    |      no      |       no      |       yes      |
| (see comments)    |              |               |                |
+-------------------+--------------+---------------+----------------+
| can be stored     |     yes      |      yes      |      no(2)     |
| in class member   |              |               |                |
+-------------------+--------------+---------------+----------------+
| can be implemented|     yes      |      yes      |       no       |
| outside of header |              |               |                |
+-------------------+--------------+---------------+----------------+
| supported without |     yes      |     no(3)     |       yes      |
| C++11 standard    |              |               |                |
+-------------------+--------------+---------------+----------------+
| nicely readable   |      no      |      yes      |      (yes)     |
| (my opinion)      | (ugly type)  |               |                |
+-------------------+--------------+---------------+----------------+

_{(1) Il existe des solutions de rechange pour surmonter cette limitation, par exemple en passant les les données en tant que paramètres supplémentaires à votre (outer) fonction: myFunction(..., callback, data) appellera callback(data) . C'est le style C "callback avec arguments", qui est possible en C++ (et d'ailleurs largement utilisé dans L'API WIN32) mais qui devrait être évité car nous avons de meilleures options en C++.}

_{(2) sauf s'il s'agit d'un modèle de classe, c'est-à-dire que la classe dans laquelle vous stockez la fonction est un modèle. Mais cela signifierait que du côté client, le type de la fonction décide du type d'objet qui stocke le callback, ce qui n'est presque jamais une option pour les cas d'utilisation réelle.}

_{(3) Pour le pré-C++11, l'utilisation boost::function}