Espaços nominais
Variantes
Acções

std::bind

Da cppreference.com
< cpp‎ | utility‎ | functional


 
 
Biblioteca de utilitários
Digite apoio (basic types, RTTI, type traits)
Gerenciamento de memória dinâmica
De tratamento de erros
Utilidades do programa
Variadic funções
Data e hora
Objetos de função
initializer_list(C++11)
bitset
hash(C++11)
Os operadores relacionais
Original:
Relational operators
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
rel_ops::operator!=
rel_ops::operator>
rel_ops::operator<=
rel_ops::operator>=
Pares e tuplas
Original:
Pairs and tuples
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
pair
tuple(C++11)
piecewise_construct_t(C++11)
piecewise_construct(C++11)
Troque, avançar e avançar
Original:
Swap, forward and move
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
swap
forward(C++11)
move(C++11)
move_if_noexcept(C++11)
declval(C++11)
 
Objetos de função
Invólucros de função
Original:
Function wrappers
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
function(C++11)
mem_fn(C++11)
bad_function_call(C++11)
Ligar
Original:
Bind
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
bind(C++11)
is_bind_expression(C++11)
is_placeholder(C++11)
_1, _2, _3, ...(C++11)
Invólucros de referência
Original:
Reference wrappers
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
reference_wrapper(C++11)
ref
cref
(C++11)
(C++11)
Invólucros operador
Original:
Operator wrappers
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
Negadores
Original:
Negators
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
Obsoleta ligantes e adaptadores
Original:
Deprecated binders and adaptors
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
unary_function(obsoleta)
binary_function(obsoleta)
ptr_fun(obsoleta)
pointer_to_unary_function(obsoleta)
pointer_to_binary_function(obsoleta)
mem_fun(obsoleta)
mem_fun_t
mem_fun1_t
const_mem_fun_t
const_mem_fun1_t
(obsoleta)
(obsoleta)
(obsoleta)
(obsoleta)
mem_fun_ref(obsoleta)
mem_fun_ref_t
mem_fun1_ref_t
const_mem_fun_ref_t
const_mem_fun1_ref_t
(obsoleta)
(obsoleta)
(obsoleta)
(obsoleta)
binder1st
binder2nd
(obsoleta)
(obsoleta)
bind1st
bind2nd
(obsoleta)
(obsoleta)
 
Defined in header <functional>
template< class F, class... Args >
/*unspecified*/ bind( F&& f, Args&&... args );
(1) (a partir do C++ 11)
template< class R, class F, class... Args >
/*unspecified*/ bind( F&& f, Args&&... args );
(2) (a partir do C++ 11)
O modelo bind função gera um invólucro de encaminhamento de chamadas para f. Chamar esse envoltório é equivalente a chamar f com alguns de seus argumentos vinculados a args.
Original:
The function template bind generates a forwarding call wrapper for f. Calling this wrapper is equivalent to invoking f with some of its arguments bound to args.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
Internamente, o invólucro contém um objeto membro da std::decay<F>::type tipo construído a partir de std::forward<F>(f), e um objeto por cada um dos args..., de std::decay<Arg_i>::type tipo, da mesma forma construído a partir de std::forward<Arg_i>(arg_i).
Original:
Internally, the wrapper holds a member object of type std::decay<F>::type constructed from std::forward<F>(f), and one object per each of args..., of type std::decay<Arg_i>::type, similarly constructed from std::forward<Arg_i>(arg_i).
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Índice

[editar] Parâmetros

f -
invocável objeto (objeto de função, o ponteiro para a função, a referência a função, o ponteiro para função de membro, ou ponteiro para dados de membro), que será obrigado a alguns argumentos
Original:
invocable object (function object, pointer to function, reference to function, pointer to member function, or pointer to member data) that will be bound to some arguments
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
args -
lista de argumentos para vincular, com os argumentos não ligados substituído pelo _1, _2, _3... espaços reservados
Original:
list of arguments to bind, with the unbound arguments replaced by the placeholders _1, _2, _3...
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

[editar] Valor de retorno

Um objeto da função T tipo não especificado, para o qual std::is_bind_expression<T>::value == true, e que pode ser armazenada em std::function. O objecto é móvel e se f todos args são móveis e, em caso contrário é copiável. O tipo define os seguintes membros:
Original:
A function object of unspecified type T, for which std::is_bind_expression<T>::value == true, and which can be stored in std::function. The object is movable if f and all args are movable, and is copyable otherwise. The type defines the following members:
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

std :: bind
Original:
std::bind
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
Return type

Member type result_type

1) If F is a pointer to function or a pointer to member function, result_type is the return type of F. If F is a class type with nested typedef result_type, then result_type is F::result_type. Otherwise no result_type is defined.

2) result_type is exactly R.

Member function operator()

Given an object g obtained from an earlier call to bind, when it is invoked in a function call expression g(u1, u2, ... uM), an invocation of the stored object of type std::decay<F>::type takes place, with arguments defined as follows:

  • If the argument is of type std::reference_wrapper<T> (e.g. std::ref or std::cref) was used in the initial call to bind, then the reference T& stored in the bound argument is passed to the invocable object.
  • If std::is_bind_expression<T>::value == true (i.e. another sbind subexpression was used as an argument in the initial call to bind), then that bind-subexpressin is invoked immediately and its result is passed to the invocable object. If the bind subexpression has any placeholder arguments, they are picked from u1, u2, ....
  • If std::is_placeholder<T>::value != 0 (i.e., _1, _2, _3, ... was used as the argument to the initial call to bind), then the argument indicated by the placeholder (u1 for _1, u2 for _2, etc) is passed to the invocable object as std::forward<Uj>(uj).
  • Otherwise, the stored argument is passed to the invocable object as-is.

If some of the arguments that are supplied in the call to g() are not matched by any placeholders stored in g, the unused arguments are evaluated and discarded.

[editar] Exceções

Só se a construção de lança std::decay<F>::type std::forward<F>(f) de lança, ou qualquer um dos construtores para std::decay<Arg_i>::type do std::forward<Arg_i>(arg_i) corrsponding lança onde Arg_i é o tipo de ordem i e arg_i é o i-ésimo argumento em Args... args.
Original:
Only throws if construction of std::decay<F>::type from std::forward<F>(f) throws, or any of the constructors for std::decay<Arg_i>::type from the corrsponding std::forward<Arg_i>(arg_i) throws where Arg_i is the ith type and arg_i is the ith argument in Args... args.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

[editar] Notas

Os argumentos para se ligam são copiados ou movidos, e nunca são passados ​​por referência a menos envolto em std::ref ou std::cref.
Original:
The arguments to bind are copied or moved, and are never passed by reference unless wrapped in std::ref or std::cref.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
Duplicar espaços reservados na expressão ligam mesmo (múltipla _1, por exemplo) são permitidos, mas os resultados só são bem definido se o argumento correspondente (u1) é um rvalue lvalue ou não-móvel.
Original:
Duplicate placeholders in the same bind expression (multiple _1's for example) are allowed, but the results are only well defined if the corresponding argument (u1) is an lvalue or non-movable rvalue.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

[editar] Exemplo

#include <random>
#include <iostream>
#include <functional>
 
void f(int n1, int n2, int n3, const int& n4, int n5)
{
    std::cout << n1 << ' ' << n2 << ' ' << n3 << ' ' << n4 << ' ' << n5 << '\n';
}
 
int g(int n1)
{
    return n1;
}
 
struct Foo {
    void print_sum(int n1, int n2)
    {
        std::cout << n1+n2 << '\n';
    }
    int data = 10;
};
 
int main()
{
    using namespace std::placeholders;
 
    // demonstrates argument reordering and pass-by-reference
    int n = 7;
    auto f1 = std::bind(f, _2, _1, 42, std::cref(n), n);
    n = 10;
    f1(1, 2, 1001); // 1 is bound by _1, 2 is bound by _2, 1001 is unused
 
    // nested bind subexpressions share the placeholders
    auto f2 = std::bind(f, _3, std::bind(g, _3), _3, 4, 5);
    f2(10, 11, 12);
 
    // common use case: binding a RNG with a distribution
    std::default_random_engine e;
    std::uniform_int_distribution<> d(0, 10);
    std::function<int()> rnd = std::bind(d, e);
    for(int n=0; n<10; ++n)
        std::cout << rnd() << ' ';
    std::cout << '\n';
 
    // bind to a member function
    Foo foo;
    auto f3 = std::bind(&Foo::print_sum, foo, 95, _1);
    f3(5);
 
    // bind to member data
    auto f4 = std::bind(&Foo::data, _1);
    std::cout << f4(foo) << '\n';
}

Output:

2 1 42 10 7
12 12 12 4 5
1 5 0 2 0 8 2 2 10 8
100
10

[editar] Veja também

espaços reservados para os argumentos não ligados em uma expressão de std::bind
Original:
placeholders for the unbound arguments in a std::bind expression
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

(constante) [edit]
(C++11)
cria um objecto de função de um apontador para um membro
Original:
creates a function object out of a pointer to a member
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

(modelo de função) [edit]