BIND a função
Vincula os argumentos a um objeto que pode ser chamado.
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
O tipo de objeto para chamar.TN
O tipo do Nth telefonar argumento.fn
O objeto a ser telefonar.tN
O argumento enésima telefonar.
Comentários
Os tipos de Fty, T1, T2, ..., TN deve ser construível, cópia e INVOKE(fn, t1, ..., tN) deve ser uma expressão válida para alguns valores w1, w2, ..., wN.
A primeira modelo de função retorna um encaminhamento de telefonar wrapper g com um tipo de resultado fraco. O efeito de g(u1, u2, ..., uM) é INVOKE(f, v1, v2, ..., vN, Classe result_of<Fty cv (V1, V2, ..., VN)>::type), onde cv é sistema autônomo VC-qualificadores de g e sistema autônomo valores e sistema autônomo tipos do limite argumentos v1, v2, ..., vN são determinados conforme especificado abaixo. Você usá-lo para BIND argumento s a um objeto que pode ser chamado para tornar um objeto que pode ser chamado com um adaptada argumento lista.
A segunda modelo de função retorna um encaminhamento de telefonar wrapper g com um tipo aninhado result_type que é um sinônimo para Ret. O efeito de g(u1, u2, ..., uM) é INVOKE(f, v1, v2, ..., vN, Ret), onde cv é sistema autônomo VC-qualificadores de g e sistema autônomo valores e sistema autônomo tipos do limite argumentos v1, v2, ..., vN são determinados conforme especificado abaixo. Você pode usá-lo para BIND os argumentos a um objeto que pode ser chamado para tornar um objeto que pode ser chamado com uma lista de argumentos personalizadas e com um tipo de retorno especificado.
sistema autônomo valores de argumentos acoplados v1, v2, ..., vN e seus tipos correspondentes V1, V2, ..., VN dependem do tipo do argumento correspondente ti do tipo Ti na telefonar para bind e sistema autônomo qualificadores de VC cv do wrapper telefonar g sistema autônomo a seguir:
if ti é do tipo reference_wrapper<T> o argumento vi é ti.get() e seu tipo Vi é T&;
Se o valor de std::tr1::is_bind_expression<Ti>::value é true o argumento vi é ti(u1, u2, ..., uM) e seu tipo Vi é result_of<Ti cv (U1&, U2&, ..., UN&>::type;
Se o valor j de std::tr1::is_placeholder<Ti>::value é o argumento não zero vi é uj e seu tipo Vi é Uj&;
Caso contrário, o argumento vi é ti e seu tipo Vi é Ti cv &.
Por exemplo, dada uma função f(int, int) a expressão bind(f, _1, 0) Retorna um encaminhamento telefonar wrapper cw de modo que cw(x) telefonars f(x, 0). A expressão bind(f, 0, _1) Retorna um encaminhamento de chama o wrapper cw de modo que cw(x) chamadas f(0, x).
O número de argumentos em uma telefonar para bind juntamente com o argumento fn deve ser igual ao número de argumentos que podem ser passados para o objeto que pode ser chamado fn. Assim, bind(cos, 1.0) está correto e ambos bind(cos) e bind(cos, _1, 0.0) estão incorretas.
O número de argumentos na função de telefonar para o wrapper telefonar retornado por bind deve ser pelo menos tão grande quanto o maior valor numerado de is_placeholder<PH>::value para todos sistema autônomo argumentos de espaço reservado na telefonar para bind. Assim, bind(cos, _2)(0.0, 1.0) está correto (e retorna cos(1.0)), e bind(cos, _2)(0.0) está incorreto.
Exemplo
// std_tr1__functional__bind.cpp
// compile with: /EHsc
#include <functional>
#include <algorithm>
#include <iostream>
using namespace std::tr1::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::tr1::bind(product, _1, 2));
std::cout << std::endl;
std::for_each(&arg[0], &arg[3], std::tr1::bind(square, _1));
return (0);
}
1^2 == 1 2^2 == 4 3^2 == 9 1*2 == 2 2*2 == 4 3*2 == 6 1^2 == 1 2^2 == 4 3^2 == 9
Requisitos
Cabeçalho:<functional>
Namespace: std::tr1