Namespaces
Variants

std:: function

From cppreference.net
C++
Utilities library
Function objects
Function invocation
(C++17) (C++23)
Identity function object
(C++20)
Old binders and adaptors
( until C++17* )
( until C++17* )
( until C++17* )
( until C++17* )
( until C++17* )
( until C++17* )
( until C++17* ) ( until C++17* ) ( until C++17* ) ( until C++17* )
( until C++20* )
( until C++20* )
( until C++17* ) ( until C++17* )
( until C++17* ) ( until C++17* )

( until C++17* )
( until C++17* ) ( until C++17* ) ( until C++17* ) ( until C++17* )
( until C++20* )
( until C++20* )
std::function
Definido en el encabezado <functional>
template < class >
class function ; /* undefined */
(desde C++11)
template < class R, class ... Args >
class function < R ( Args... ) > ;
(desde C++11)

La plantilla de clase std::function es un contenedor de funciones polimórfico de propósito general. Las instancias de std::function pueden almacenar, copiar e invocar cualquier CopyConstructible Callable objetivo -- funciones (a través de punteros a las mismas), expresiones lambda , expresiones de enlace , u otros objetos función, así como punteros a funciones miembro y punteros a miembros de datos.

El objeto invocable almacenado se denomina objetivo de std::function . Si un std::function no contiene ningún objetivo, se denomina vacío . Invocar el objetivo de un std::function vacío resulta en que se lance la excepción std::bad_function_call .

std::function satisface los requisitos de CopyConstructible y CopyAssignable .

Contenidos

Tipos de miembros

Tipo Definición
result_type R
argument_type
(obsoleto en C++17) (eliminado en C++20) 		T si sizeof... ( Args ) == 1 y T es el primer y único tipo en Args...
first_argument_type
(obsoleto 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
(obsoleto 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

construye una nueva instancia de std::function
(función miembro pública)
destruye una instancia de std::function
(función miembro pública)
asigna un nuevo objetivo
(función miembro pública)
intercambia los contenidos
(función miembro pública)
(eliminado en C++17)
asigna un nuevo objetivo
(función miembro pública)
verifica si contiene un objetivo
(función miembro pública)
invoca el objetivo
(función miembro pública)
Acceso al objetivo
obtiene el typeid del objetivo almacenado
(función miembro pública)
obtiene un puntero al objetivo almacenado
(función miembro pública)

Funciones no miembro

(C++11)
especializa el algoritmo std::swap
(plantilla de función)
(eliminado en C++20)
compara un std::function con nullptr
(plantilla de función)

Clases auxiliares

(C++11) (until C++17)
especializa el trait de tipo std::uses_allocator
(especialización de plantilla de clase)

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

Notas

Se debe tener cuidado cuando un std::function , cuyo tipo de resultado es una referencia, se inicializa desde una expresión lambda sin un tipo-de-retorno-final. Debido a la forma en que funciona la deducción auto, dicha expresión lambda siempre retornará un prvalue. Por lo tanto, la referencia resultante normalmente se vinculará a un temporal cuya duración finaliza cuando std::function::operator() retorna.

(until C++23)

Si un std::function que retorna una referencia se inicializa desde una función u objeto función que retorna un prvalue (incluyendo una expresión lambda sin tipo-de-retorno-final), el programa está mal formado porque se prohíbe vincular la referencia retornada a un objeto temporal.

(since C++23) 
std::function<const int&()> F([] { return 42; }); // Error desde C++23: no se puede enlazar
                                                  // la referencia devuelta a un temporal
int x = F(); // Comportamiento indefinido hasta C++23: el resultado de F() es una referencia colgante
std::function<int&()> G([]() -> int& { static int i{0x2A}; return i; }); // Correcto
std::function<const int&()> H([i{052}] -> const int& { return i; }); // Correcto

Ejemplo

Ejecutar este código 
#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 una 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 miembro de datos
    std::function<int(Foo const&)> f_num = &Foo::num_;
    std::cout << "num_: " << f_num(foo) << '\n';
    // almacenar una llamada a una 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 una 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 "lambda recursiva"; consciente del sobrecosto adicional
        std::function<int(int)> fac = [&](int n) { return (n < 2) ? 1 : n * fac(n - 1); };
        // nota 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) << ";  ";
    std::cout << '\n';
}

Salida posible: 

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

Véase también

(C++23)
envoltorio no copiable de cualquier objeto invocable que soporta calificadores en una firma de llamada dada
(plantilla de clase)
(C++26)
envoltorio copiable de cualquier objeto invocable copiable que soporta calificadores en una firma de llamada dada
(plantilla de clase)
(C++26)
envoltorio no propietario de cualquier objeto invocable
(plantilla de clase)
(C++11)
la excepción lanzada al invocar un std::function vacío
(clase)
(C++11)
crea un objeto función a partir de un puntero a miembro
(plantilla de función)
typeid consulta información de un tipo, devolviendo un objeto std::type_info que representa el tipo