Pasar una función como parámetro en C++

Una función es un conjunto de declaraciones que toman entradas, realizan algún cálculo específico y producen una salida. La idea de usar funciones es realizar algunas tareas comunes o repetidas juntas y crear una función para que, en lugar de escribir el mismo código una y otra vez para diferentes entradas. La forma general de una función es:

return_type nombre_función([ arg1_type arg1_name, … ]) {

     // Realizar operaciones

}

Pasar una función como argumento es un concepto útil en C/C++ . Este concepto ya se usó al pasar una función de comparación personalizada como argumento en std::sort() para ordenar una secuencia de objetos según la necesidad. En este artículo, discutiremos diferentes formas de diseñar funciones que acepten otra función como argumento.

Pasando puntero a una función :

Una función también se puede pasar a otra función pasando su dirección a esa función. A continuación se muestra el programa C++ para ilustrar lo mismo:

// C++ program to pass function as a
// pointer to any function
  
#include <iostream>
using namespace std;
  
// Function that add two numbers
int add(int x, int y)
{
    return x + y;
}
  
// Function that multiplies two
// numbers
int multiply(int x, int y)
{
    return x * y;
}
  
// Function that takes a pointer
// to a function
int invoke(int x, int y,
           int (*func)(int, int))
{
    return func(x, y);
}
  
// Driver Code
int main()
{
    // Pass pointers to add & multiply
    // function as required
    cout << "Addition of 20 and 10 is ";
    cout << invoke(20, 10, &add)
         << '\n';
  
    cout << "Multiplication of 20"
         << " and 10 is ";
    cout << invoke(20, 10, &multiply)
         << '\n';
  
    return 0;
}

Addition of 20 and 10 is 30
Multiplication of 20 and 10 is 200

Usando std::function<> :

En C++ 11 , hay una clase de plantilla std::function<> que permite pasar funciones como objetos. Un objeto de std::function<>se puede crear de la siguiente manera. 

std::function<return_type(arg1_type, arg2-type…)> nombre_obj

       // Este objeto se puede usar para llamar a la función como se muestra a continuación

return_type catch_variable = obj_name(arg1, arg2);

A continuación se muestra el programa para ilustrar el paso de un objeto de función como parámetro a otra función:

// C++ program to illustrate the passing
// of functions as an object parameter
#include <functional>
#include <iostream>
using namespace std;
  
// Define add and multiply to
// return respective values
int add(int x, int y)
{
    return x + y;
}
int multiply(int x, int y)
{
    return x * y;
}
  
// Function that accepts an object of
// type std::function<> as a parameter
// as well
int invoke(int x, int y,
           function<int(int, int)> func)
{
    return func(x, y);
}
  
// Driver code
int main()
{
    // Pass the required function as
    // parameter using its name
    cout << "Addition of 20 and 10 is ";
    cout << invoke(20, 10, &add)
         << '\n';
  
    cout << "Multiplication of 20"
         << " and 10 is ";
    cout << invoke(20, 10, &multiply)
         << '\n';
  
    return 0;
}

Addition of 20 and 10 is 30
Multiplication of 20 and 10 is 200

Usando lambdas :

Lambdas en C++ proporciona una forma de definir objetos de función anónimos, únicos y en línea. Estas lambdas se pueden definir en un lugar donde se requiere pasar una función como argumento. A continuación se muestra el programa C++ para ilustrar lo mismo: 

// C++ program to pass the function as
// parameter as a lambda expression
#include <functional>
#include <iostream>
using namespace std;
  
// Function that takes a pointer
// to a function
int invoke(int x, int y,
           function<int(int, int)> func)
{
    return func(x, y);
}
  
// Driver Code
int main()
{
  
    // Define lambdas for addition and
    // multiplication operation where
    // we want to pass another function
    // as a parameter
  
    // Perform Addition
    cout << "Addition of 20 and 10 is ";
    int k = invoke(20, 10,
                   [](int x,
                      int y) -> int {
                       return x + y;
                   });
  
    cout << k << '\n';
  
    // Perform Multiplication
    cout << "Multiplication of 20"
         << " and 10 is ";
    int l = invoke(20, 10,
                   [](int x,
                      int y) -> int {
                       return x * y;
                   });
  
    cout << l << '\n';
  
    return 0;
}

Addition of 20 and 10 is 30
Multiplication of 20 and 10 is 200