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.
Contenido |
[editar] 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...
|
[editar] 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) | |
[editar] 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) |
[editar] Clases auxiliares
| (C++11) (hasta C++17) |
Especializa el rasgo de tipo std::uses_allocator. (especialización de plantilla de clase) |
[editar] Guías de deducción(desde C++17)
[editar] 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
[editar] 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;
[editar] 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) |
