Espaces de noms
Variantes
Affichages
Actions

std::bind

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


 
 
 
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.
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.
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)
 
Defined in header <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 modèle de fonction bind génère un wrapper pour un renvoi d'appel à f. L'appel de ce wrapper é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, le wrapper détient un objet de type std::decay<F>::type construit à partir de std::forward<F>(f), et un objet par chacun des args..., de type std::decay<Arg_i>::type, de même construit à 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.

Sommaire

[modifier] Paramètres

f -
Objet invocable (objet fonction, pointeur de fonction, référence à une fonction, 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 les espaces réservés _1, _2, _3...
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.

[modifier] Retourne la valeur

Un objet fonction de type non spécifié T, pour lequel std::is_bind_expression<T>::value == true, et qui peut être stocké dans std::function. L'objet est déplaçable si f et tous les args le sont même, et copiable sinon. 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)
Si F est un pointeur de fonction ou un pointeur vers une fonction membre, result_type est le type de retour de F. Si F est un type Class avec un typedef imbriqué, alors result_type est de type F::result_type. Sinon aucun result_type n'est définit.
Original:
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.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.


2)
result_type est exactement R.
Original:
result_type is exactly R.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.


Member function operator()

Soit un objet g obtenu à partir d'un appel récent à bind, Quand il est invoqué dans une expression d'appel de fonction g(u1, u2, ... uM), une invocation des objets stockés de type std::decay<F>::type doit avoir lieu avec les arguments qui suivent:
Original:
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:
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
  • Si l'argument est de type std::reference_wrapper<T> (e.g. std::ref ou std::cref) est utilisé dans l'appel intial à bind, alors la référence T& stockée dans l'argument lié est passée à l'objet invocable.
    Original:
    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.
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.
  • Si std::is_bind_expression<T>::value == true (i.e. une autre sous-expression sbind est utilisée comme un argument dans l'appel initial à bind), alors cette sous-expression de bind serait invoquée immédiatement dont le résultat est passé à l'objet invocable. Si la sous-expression bind contient des espaces réservés en tant qu'arguments, ils auraient dû être piqués parmi u1, u2, ....
    Original:
    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, ....
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.
  • Si std::is_placeholder<T>::value != 0 (i.e., _1, _2, _3, ... est utilisé en tant qu'un argument à l'appel initial vers bind), alors l'argument indiqué par l'espace réservé (u1 pour _1, u2 pour _2, etc) est passé à l'objet invocable comme std::forward<Uj>(uj).
    Original:
    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).
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.
  • Autrement, l'argument stocké est passé à l'objet invocable tel qu'il est.
    Original:
    Otherwise, the stored argument is passed to the invocable object as-is.
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.
Si certains arguments qui sont fournis dans l'appel à g() ne sont pas asimilés à aucun espace réservé stocké à g, les arguments inutiles seraient évalués puis écartés.
Original:
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.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

[modifier] Exceptions

Lancée seulement si la construction de std::decay<F>::type à partir de std::forward<F>(f) lance, ou l'un des constructeurs pour std::decay<Arg_i>::type à partir de la std::forward<Arg_i>(arg_i) correspondante lance une exception.Où Arg_i est le i'ème type et arg_i est l'ième argument parmi 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.

[modifier] Notes

Les arguments de liaison sont copiés ou déplacés, et ne sont jamais passés par référence, sauf enveloppés 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.
Des dupliques d'espaces réservés dans la même expression bind (par example _1's multiples) sont autorisés, mais les résultats ne sont bien définis que si l'argument correspondant (u1) est une lvalue ou non déplaçable rvalue.
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.

[modifier] 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;
 
    // demontrer l'ordre des arguments et l'appel par référence.
    int n = 7;
    auto f1 = std::bind(f, _2, _1, 42, std::cref(n), n);
    n = 10;
    f1(1, 2, 1001); // 1 est lié par _1, 2 est lié par _2, 1001 est inutile.
 
    // Une sous-expression bind nichée, qui partage encore les espaces réservés (placeholders)
    auto f2 = std::bind(f, _3, std::bind(g, _3), _3, 4, 5);
    f2(10, 11, 12);
 
    // Cas d'usage commun: liaison d' RNG avec une 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';
 
    // liaison vers une fonction membre.
    Foo foo;
    auto f3 = std::bind(&Foo::print_sum, foo, 95, _1);
    f3(5);
 
    // liaison vers une donnée membre.
    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

[modifier] Voir aussi

placeholders (numéros de paramètre) pour les std::bind
(constante) [edit]
(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) [edit]