std::function
| 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
| 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 destino. (función miembro pública) | |
| Intercambia el contenido. (función miembro pública) | |
(eliminado en C++17) |
Asigna un nuevo destino. (función miembro pública) |
| Verifica contiene un destino válido. (función miembro pública) | |
| Invoca el destino. (función miembro pública) | |
Acceso al destino | |
Obtiene el typeid del destino almacenado. (función miembro pública) | |
| Obtiene un puntero al destino 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 una instancia de std::function con nullptr. (plantilla de función) |
Clases auxiliares
(C++11) (hasta C++17) |
Especializa el rasgo 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 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
(C++23) |
Envuelve un objeto invocable de cualquier tipo con la signatura de llamada a función especificada. (plantilla de clase) |
(C++11) |
La excepción que se lanza cuando se invoca un objeto std::function vacío. (clase) |
(C++11) |
Crea un objeto función de un puntero a un miembro. (plantilla de función) |