std::function - cppreference.com

De cppreference.com

Definido en el archivo de encabezado `<functional>`
`template< class > class function; /* no definido */`		(desde C++11)
`template< class R, class... Args > class function<R(Args...)>;`		(desde C++11)

La plantilla de clase std::function es un contenedor polimórfico de función de propósito general. Las instancias de std::function pueden almacenar, copiar e invocar cualquier función destino Invocable ConstruiblePorCopia, expresiones lambda, expresiones de vinculación, u otros objetos función, así como punteros a función miembro y punteros a datos miembro.

El objeto invocable almacenado se llama el destino de std::function. Si un objeto de tipo std::function no contiene un destino, se le denomina vacío. Invocar el destino de un objeto tipo std::function vacío lanza una excepción std::bad_function_call.

std::function satisface los requisitos de ConstruiblePorCopia y AsignablePorCopia.

Tipos miembro

Tipo	Definición
`result_type`	`R`
`argument_type`(en desuso en C++17)(eliminado en C++20)	`T` si `sizeof...(Args)==1` y `T` es el primero y único tipo en `Args...`
`first_argument_type`(en desuso en C++17)(eliminado en C++20)	`T1` si `sizeof...(Args)==2` y `T1` es el primero de los dos tipos en `Args...`
`second_argument_type`(en desuso en C++17)(eliminado en C++20)	`T2` si `sizeof...(Args)==2` y `T2` es el segundo de los dos tipos en `Args...`

Funciones miembro

(constructor)	Construye una nueva instancia de std::function. (función miembro pública) [editar]
(destructor)	Destruye una instancia de `std::function`. (función miembro pública) [editar]
operator=	Asigna un nuevo destino. (función miembro pública) [editar]
swap	Intercambia el contenido. (función miembro pública) [editar]
assign (eliminado en C++17)	Asigna un nuevo destino. (función miembro pública) [editar]
operator bool	Verifica contiene un destino válido. (función miembro pública) [editar]
operator()	Invoca el destino. (función miembro pública) [editar]
Acceso al destino
target_type	Obtiene el `typeid` del destino almacenado. (función miembro pública) [editar]
target	Obtiene un puntero al destino almacenado. (función miembro pública) [editar]

Funciones no miembro

Clases auxiliares

Guías de deducción(desde C++17)

Notas

Se debe tener cuidado cuando un objeto tipo std::function cuyo tipo de resultado es una referencia inicializada desde una expresión lambda sin un tipo de retorno al final. Debido a la forma en que funciona la deducción automática, tal expresión lambda siempre devolverá un pr-valor. Por lo tanto, la referencia resultante generalmente se vinculará a un temporal cuya vida finaliza cuando std::function::operator() retorne.

std::function<const int&()> F([]{ return 42; });
int x = F(); // Comportamiento no definido: el resultado de F() es una referencia pendiente

Ejemplo

#include <functional>
#include <iostream>
 
struct Foo {
    Foo(int num) : num_(num) {}
    void print_add(int i) const { std::cout << num_+i << '\n'; }
    int num_;
};
 
void print_num(int i)
{
    std::cout << i << '\n';
}

struct PrintNum {
    void operator()(int i) const
    {
        std::cout << i << '\n';
    }
};
 
int main()
{
    // almacenar una función libre
    std::function<void(int)> f_display = print_num;
    f_display(-9);
 
    // almacenar una lambda
    std::function<void()> f_display_42 = []() { print_num(42); };
    f_display_42();
 
    // almacenar el resultado de una llamada a std::bind
    std::function<void()> f_display_31337 = std::bind(print_num, 31337);
    f_display_31337();
 
    // almacenar una llamada a función miembro
    std::function<void(const Foo&, int)> f_add_display = &Foo::print_add;
    const Foo foo(314159);
    f_add_display(foo, 1);
    f_add_display(314159, 1);
   
    // almacenar una llamada a un accesor de dato miembro
    std::function<int(Foo const&)> f_num = &Foo::num_;
    std::cout << "num_: " << f_num(foo) << '\n';
    
    // almacenar una llamada a función miembro y objeto
    using std::placeholders::_1;
    std::function<void(int)> f_add_display2 = std::bind( &Foo::print_add, foo, _1 );
    f_add_display2(2);
 
    // almacenar una llamada a función miembro y puntero a objeto
    std::function<void(int)> f_add_display3 = std::bind( &Foo::print_add, &foo, _1 );
    f_add_display3(3);

    // almacenar una llamada a un objeto función
    std::function<void(int)> f_display_obj = PrintNum();
    f_display_obj(18);

    auto factorial = [](int n) {
        // almacenar un objeto lambda para emular una "lambda recursiva"; consciente del costo extra
        std::function<int(int)> fac = [&](int n){ return (n < 2) ? 1 : n*fac(n-1); };
        // observa que "auto fac = [&](int n){...};" no funciona en llamadas recursivas
        return fac(n);
    };
    for (int i{5}; i != 8; ++i) { std::cout << i << "! = " << factorial(i) << ";  "; }
}

Posible salida:

-9
42
31337
314160
314160
num_: 314159
314161
314162
18
5! = 120;  6! = 720;  7! = 5040;

Véase también

	Envuelve un objeto invocable de cualquier tipo con la signatura de llamada a función especificada. (plantilla de clase) [editar]
	La excepción que se lanza cuando se invoca un objeto std::function vacío. (clase) [editar]
	Crea un objeto función de un puntero a un miembro. (plantilla de función) [editar]