bind Function

enlaza argumentos a un objeto accesible.

template<class Fty, class T1, class T2, ..., class TN>
   unspecified bind(Fty fn, T1 t1, T2 t2, ..., TN tN);
template<class Ret, class Fty, class T1, class T2, ..., class TN>
   unspecified bind(Fty fn, T1 t1, T2 t2, ..., TN tN);

Parámetros

Fty
El tipo de objeto a la llamada.
TN
El tipo de argumento de la llamada de Enésimo.
fn
El objeto de llamada.
tN
El argumento de llamada de Enésimo.

Comentarios

Los tipos Fty, T1, T2, ..., TN deben ser copia construible, y INVOKE(fn, t1, ..., tN) debe ser una expresión válida con algunos valores w1, w2, ..., wN.

La primera función de la plantilla devuelve un contenedor g de llamada de reenvío con un tipo de resultado parcial.El efecto de g(u1, u2, ..., uM) es INVOKE(f, v1, v2, ..., vN,result_of Class<Ftycv(V1, V2, ..., VN)>::type), donde los cv-calificadores cv de g y determinan los valores y los tipos de los argumentos enlazados v1, v2, ..., vN especificadas a continuación.Se utiliza para enlazar argumentos a un objeto accesible para crear un objeto accesible con una lista de argumentos adaptada.

La segunda función de la plantilla devuelve un contenedor g de llamada de reenvío con un tipo anidado result_type que es un sinónimo de Ret.El efecto de g(u1, u2, ..., uM) es INVOKE(f, v1, v2, ..., vN, Ret), donde los cv-calificadores cv de g y determinan los valores y los tipos de los argumentos enlazados v1, v2, ..., vN especificadas a continuación.Se utiliza para enlazar argumentos a un objeto accesible para crear un objeto accesible con una lista de argumentos adecuado y con un tipo de valor devuelto especificado.

Los valores de los argumentos enlazados v1, v2, ..., vN y sus tipos correspondientes V1, V2, ..., VN dependen del tipo del argumento correspondiente ti de Ti escrito en la llamada a bind y los cv-calificadores cv de contenedor g de llamada como sigue:

si ti es de reference_wrapper<T> escrito el argumento vi es ti.get() y su tipo Vi es T&;

si el valor de std::is_bind_expression<Ti>::value es true el argumento vi es ti(u1, u2, ..., uM) y su tipo Vi es result_of<Ticv(U1&, U2&, ..., UN&>::type;

si el valor j de std::is_placeholder<Ti>::value no es cero el argumento vi es uj y su tipo Vi es Uj&;

si no el argumento vi es ti y su tipo Vi es Ticv&.

Por ejemplo, dada una función f(int, int) la expresión bind(f, _1, 0) devuelve un contenedor cw de llamada de reenvío tales que cw(x) llama f(x, 0).La expresión bind(f, 0, _1) devuelve un contenedor cw de llamada de reenvío tales que cw(x) llama f(0, x).

El número de argumentos en una llamada a bind además del argumento fn debe ser igual al número de argumentos que se pueden pasar al objeto accesible fn.así, bind(cos, 1.0) es correcto, y bind(cos) y bind(cos, _1, 0.0) son incorrectos.

El número de argumentos en la llamada de función al contenedor de llamada devuelto por bind debe ser por lo menos tan grande como el valor numerado más alto de is_placeholder<PH>::value para todos los argumentos del marcador en la llamada a bind.así, bind(cos, _2)(0.0, 1.0) es correcto (y devuelve cos(1.0)), y bind(cos, _2)(0.0) es incorrecto.

Ejemplo

// std_tr1__functional__bind.cpp 
// compile with: /EHsc 
#include <functional> 
#include <algorithm> 
#include <iostream> 
 
using namespace std::placeholders; 
 
void square(double x) 
    { 
    std::cout << x << "^2 == " << x * x << std::endl; 
    } 
 
void product(double x, double y) 
    { 
    std::cout << x << "*" << y << " == " << x * y << std::endl; 
    } 
 
int main() 
    { 
    double arg[] = {1, 2, 3}; 
 
    std::for_each(&arg[0], arg + 3, square); 
    std::cout << std::endl; 
 
    std::for_each(&arg[0], arg + 3, std::bind(product, _1, 2)); 
    std::cout << std::endl; 
 
    std::for_each(&arg[0], arg + 3, std::bind(square, _1)); 
 
    return (0); 
    }

Requisitos

encabezado: <funcional>

espacio de nombres: std

Vea también

Referencia

is_bind_expression Class

_1 Object

Last updated on 2013-02-19