Las plantillas de función bind_front y bind_back generan un envoltorio de llamada de reenvío para f. Llamar a este envoltorio es equivalente a invocar f con sus parámetros sizeof...(Args) (1) first o (2) last vinculados a args.

En otras palabras:

• std::bind_front(f, bound_args...)(call_args...) es equivalente a std::invoke(f, bound_args..., call_args...).
• std::bind_back(f, bound_args...)(call_args...) es equivalente a std::invoke(f, call_args..., bound_args...).

El programa está mal formado si cualquiera de los siguientes es false:

• std::is_constructible_v<std::decay_t<F>, F>
• std::is_move_constructible_v<std::decay_t<F>>
• (std::is_constructible_v<std::decay_t<Args>, Args> && ...)
• (std::is_move_constructible_v<std::decay_t<Args>> && ...)

[editar] Parámetros

[editar] Valor de retorno

Un objeto función de tipo T que no está especificado, excepto que los tipos de objetos devueltos por dos llamadas a std::bind_front o std::bind_back con los mismos argumentos son los mismos.

El objeto devuelto (el envoltorio de llamada) tiene las siguientes propiedades:

[editar] Excepciones

Solo lanza una excepción si la construcción del objeto función almacenado lanza o cualquiera de los argumentos vinculados lanza.

[editar] Notas

Estas plantillas de función están destinadas a reemplazar std::bind. A diferencia de std::bind, no admiten la reorganización arbitraria de argumentos y no tienen un tratamiento especial para expresiones de vinculación anidadas o std::reference_wrapper. Por otro lado, prestan atención a la categoría de valor del objeto envoltorio de llamada y propagan la especificación de excepción del operador de llamada a función subyacente.

Como se describe en std::invoke, al invocar un puntero a función miembro no estática o un puntero a dato miembro no estático, el primer argumento debe ser una referencia o puntero (incluido, posiblemente, un puntero inteligente como std::shared_ptr y std::unique_ptr) a un objeto a cuyo miembro se accederá.

Los argumentos para std::bind_front o std::bind_back se copian o mueven, y nunca se pasan por referencia a menos que estén envueltos en std::ref o std::cref.

[editar] Ejemplo

#include <functional>
#include <iostream>
 
int menos(int a, int b)
{
    return a - b;
}
 
struct S
{
    int val;
    int menos(int arg) const noexcept { return val - arg; }
};
 
int main()
{
    auto cincuenta_menos = std::bind_front(menos, 50);
    std::cout << cincuenta_menos (3) << '\n'; // equivalente a `menos(50, 3)`
 
    auto miembro_menos = std::bind_front(&S::menos, S{50});
    std::cout << miembro_menos (3) << '\n'; // equivalente a `S tmp{50}; tmp.menos(3)`
 
    // se conserva la especificación noexcept
    static_assert(! noexcept(cincuenta_menos (3)));
    static_assert(noexcept(miembro_menos (3)));
 
    // vincular a una lambda
    auto mas = [](int a, int b) { return a + b; };
    auto cuarenta_mas = std::bind_front(mas, 40);
    std::cout << cuarenta_mas(7) << '\n'; // equivalente a `mas(40, 7)`
 
    #ifdef __cpp_lib_bind_back
    auto mult_y_sumar = [](int a, int b, int c) { return a * b + c; };
    auto mult_mas_siete = std::bind_back(mult_y_sumar, 7);
    std::cout << mult_mas_siete(4, 10) << '\n'; // equivalente a `mult_y_sumar(4, 10, 7)`
    #endif
}

47
47
47
47

[editar] Véase también