bind, fonction
Lie des arguments à un objet appelable.
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);
Paramètres
Fty
Le type de l'objet à l'appel.TN
Le type de l'énième argument appelante.fn
L'objet à l'appel.tN
Le nième argument appelante.
Notes
Les types Fty, T1, T2, ..., TN doivent être copie construtible, et INVOKE(fn, t1, ..., tN) doit être une expression valide pour les valeurs w1, w2, ..., wN.
La première fonction de modèle retourne un wrapper g d'appel de transfert du type de résultat faible. L'effet d'g(u1, u2, ..., uM) est INVOKE(f, v1, v2, ..., vN, result_of, classe<Fty cv (V1, V2, ..., VN)>::type), où cv est cv- les identificateurs d'g et les valeurs et les types des arguments liés v1, v2, ..., vN sont déterminées comme spécifié ci-dessous. Vous l'utilisez pour lier des arguments à un objet appelable pour créer un objet appelable à la liste des arguments approprié.
La deuxième fonction de modèle retourne un wrapper g d'appel de transfert de type imbriqué result_type synonyme pour Ret. L'effet d'g(u1, u2, ..., uM) est INVOKE(f, v1, v2, ..., vN, Ret), où cv est cv- les identificateurs d'g et les valeurs et les types des arguments liés v1, v2, ..., vN sont déterminées comme spécifié ci-dessous. Vous l'utilisez pour lier des arguments à un objet appelable pour créer un objet appelable à la liste des arguments approprié et dont le type de retour spécifié.
Les valeurs des arguments liés v1, v2, ..., vN et leurs types correspondants V1, V2, ..., VN dépendent du type de l'argument correspondant ti du type Ti dans l'appel à bind et les cv- qualificateurs cv du wrapper g appelante comme suit :
si ti est de type reference_wrapper<T> l'argument vi est ti.get() et son type Vi est T&;
si la valeur d'std::is_bind_expression<Ti>::value est true l'argument vi est ti(u1, u2, ..., uM) et son type Vi est result_of<Ti cv (U1&, U2&, ..., UN&>::type;
si la valeur j d'std::is_placeholder<Ti>::value est différent de zéro vi l'argument est uj et son type Vi est Uj&;
si l'argument vi est ti et son type Vi est Ti cv &.
Par exemple, considérons une fonction f(int, int) l'expression bind(f, _1, 0) retourne un wrapper cw d'appel de transfert telles qu' cw(x) appelle f(x, 0). L'expression bind(f, 0, _1) retourne un wrapper cw d'appel de transfert telles qu' cw(x) appelle f(0, x).
Le nombre d'arguments dans un appel à bind outre l'argument fn doit être égal au nombre d'arguments qui peuvent être passés à l'objet appelable fn. Par conséquent, bind(cos, 1.0) est correct, et bind(cos) et bind(cos, _1, 0.0) sont incorrectes.
Le nombre d'arguments dans l'appel de fonction au wrapper d'appel retourné par bind doit être au moins égal à la moitié de la valeur du numéro le plus élevé d'is_placeholder<PH>::value pour tous les arguments d'espace réservé dans l'appel à bind. Par conséquent, bind(cos, _2)(0.0, 1.0) est correcte (et retourne cos(1.0)), et bind(cos, _2)(0.0) est incorrect.
Exemple
// 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);
}
Configuration requise
En-tête : <functional>
Espace de noms : std