std::bind

 

C++

Langage

Concepts

Bibliothèque d'utilitaires

Bibliothèque pour les chaînes de caractères

Bibliothèque de conteneurs

Bibliothèque d'algorithmes

Bibliothèque d'itérateurs

Bibliothèque pour le calcul numérique

Bibliothèque pour les entrées/sorties

Bibliothèque pour la régionalisation

Bibliothèque pour les expressions régulières (C++11)

Bibliothèque pour les opérations atomiques (C++11)

Bibliothèque pour les processus légers (threads) (C++11)

 

Bibliothèque d'utilitaires

Soutien des types fondamentaux (basic types, RTTI, type traits)

Gestion dynamique de la mémoire

Gestion d'erreur

Soutien à l'exécution

Fonctions variadic

Date et heure

Foncteurs

initializer_list (C++11)

bitset

hash (C++11)

Opérateurs relationnels

rel_ops::operator!= rel_ops::operator> rel_ops::operator<= rel_ops::operator>=

Paires et tuples

pair

tuple (C++11)

piecewise_construct_t (C++11)

piecewise_construct (C++11)

swap, forward et move

swap

forward (C++11)

move (C++11)

move_if_noexcept (C++11)

declval (C++11)

 

Objets Function

Emballages de fonction 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)
Lier 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)
Emballages de référence 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)
Emballages opérateur 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.
plus minus negate multiplies divides modulus logical_and logical_or logical_not	equal_to not_equal_to greater less greater_equal less_equal bit_and bit_or bit_xor
Négateurs Original: Negators The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions.
unary_negate binary_negate	not1 not2
Obsolète liants et des adaptateurs 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 (obsolète)
binary_function (obsolète)
ptr_fun (obsolète)
pointer_to_unary_function (obsolète)
pointer_to_binary_function (obsolète)
mem_fun (obsolète)
mem_fun_t mem_fun1_t const_mem_fun_t const_mem_fun1_t (obsolète) (obsolète) (obsolète) (obsolète)
mem_fun_ref (obsolète)
mem_fun_ref_t mem_fun1_ref_t const_mem_fun_ref_t const_mem_fun1_ref_t (obsolète) (obsolète) (obsolète) (obsolète)
binder1st binder2nd (obsolète) (obsolète)
bind1st bind2nd (obsolète) (obsolète)

 

Défini dans l'entête <functional>
template< class F, class... Args > /*unspecified*/ bind( F&& f, Args&&... args );	(1)	(depuis C++11)
template< class R, class F, class... Args > /*unspecified*/ bind( F&& f, Args&&... args );	(2)	(depuis C++11)

Le bind modèle de fonction génère un wrapper pour le renvoi d'appel f. L'appel de cette enveloppe équivaut à invoquer f avec certains de ses arguments liés à 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.

En interne, l'emballage est titulaire d'un objet membre de std::decay<F>::type type construit à partir std::forward<F>(f), et un objet par chacun des args..., de std::decay<Arg_i>::type type, de même construit à partir 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.

Paramètres

f	-	invocable objet (objet fonction, pointeur de fonction, la référence à la fonction, le pointeur vers une fonction membre, ou un pointeur vers les données membres) qui sera liée à certains arguments 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	-	liste des arguments à lier, avec les arguments non liés remplacés par le _1, _2, _3... espaces réservés 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.

Retourne la valeur

Un objet de fonction de T de type non spécifié, pour lequel std::is_bind_expression<T>::value == true, et qui peuvent être stockées dans std::function. L'objet est mobile et si tous f args sont mobiles, et est copiable contraire. Le type définit les membres suivants:

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.

Exceptions

Lance que si la construction de std::decay<F>::type de std::forward<F>(f) jette, ou l'un des constructeurs pour std::decay<Arg_i>::type de la std::forward<Arg_i>(arg_i) corrsponding jette Arg_i où est le type i et arg_i est l'argument ième 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.

Notes

Les arguments de liaison sont copiés ou déplacés, et ne sont jamais passés par référence, sauf enveloppé dans 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.

Dupliquer des espaces réservés dans l'expression même bind (multiple de _1 par exemple) sont autorisés, mais les résultats ne sont bien définis si l'argument correspondant (u1) est une lvalue rvalue ou non mobile .

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.

Exemple

#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';
}

Résultat :

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

Voir aussi

_1, _2, _3, _4, ... (C++11)	placeholders (numéros de paramètre) pour les std::bind (constante)
mem_fn (C++11)	crée un foncteur permettant d'accéder à un membre de classe donné; le foncteur prend alors en paramètre une instance de la classe (fonction générique)