¿Debo usar std:: function o un puntero de función en C++?

En resumen, el uso std::function a menos que tengas una razón para no hacerlo.

Los punteros de función tienen la desventaja de no ser capaces de capturar algún contexto. Por ejemplo, no podrá pasar una función lambda como devolución de llamada que capture algunas variables de contexto (pero funcionará si no captura ninguna). Llamar a una variable miembro de un objeto (es decir, no estática) tampoco es posible, ya que el objeto (this - puntero) debe ser capturar.⁽¹⁾

std::function (dado que C++11) es principalmente para almacenar una función (pasarla no requiere que se almacene). Por lo tanto, si desea almacenar la devolución de llamada, por ejemplo, en una variable miembro, es probablemente su mejor opción. Pero también si no lo almacena, es una buena "primera opción", aunque tiene la desventaja de introducir algunos gastos generales (muy pequeños) cuando se llama (por lo que en una situación muy crítica de rendimiento podría ser un problema, pero en la mayoría no debería). Es muy "universal": si te importa mucho el código consistente y legible, así como no quieres pensar en cada elección que haces (es decir, quieres mantenerlo simple), usa std::function para cada función que pases.

Piense en una tercera opción: Si está a punto de implementar una pequeña función que luego informa algo a través de la función de devolución de llamada proporcionada, considere un parámetro de plantilla , que luego puede ser cualquier objeto llamable , es decir, un puntero de función, una functor, a lambda, a std::function,... El inconveniente aquí es que su función (externa) se convierte en una plantilla y, por lo tanto, debe implementarse en el encabezado. Por otro lado se obtiene la ventaja de que la llamada a la devolución de llamada puede ser inlineada, ya que el código de cliente de su función (externa) "ve" la llamada a la devolución de llamada será la información de tipo exacto que está disponible.

Ejemplo para la versión con el parámetro template (escribe & en lugar de && para pre-C++11):

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

As se puede ver en la siguiente tabla, todos ellos tienen sus ventajas y desventajas:

+-------------------+--------------+---------------+----------------+
|                   | 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) Existen soluciones alternativas para superar esta limitación, por ejemplo, pasando los datos adicionales como parámetros adicionales a su función (externa): myFunction(..., callback, data) llamará a callback(data). Ese es el estilo C "callback con argumentos", que es posible en C++ (y por cierto muy utilizado en la API de WIN32), pero debe evitarse porque tenemos mejores opciones en C++.}

_{(2) A menos que estemos hablando de una plantilla de clase, es decir, la clase en la que almacena la función es una plantilla. Pero eso significaría que en el lado del cliente el tipo de la función decide el tipo del objeto que almacena la devolución de llamada, que casi nunca es una opción para casos de uso reales.}

_{(3) Para pre-C++11, use boost::function}