Espaces de noms
Variantes
Affichages
Actions

std::placeholders::_1, std::placeholders::_2, ..., std::placeholders::_N

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>
extern /*unspecified*/ _1;

extern /*unspecified*/ _2;
.
.

extern /*unspecified*/ _N;
L'espace de noms std::placeholders contient les objets espace réservé [_1, . . . _N]N est une implémentation définis nombre maximum .
Original:
The std::placeholders namespace contains the placeholder objects [_1, . . . _N] where N is an implementation defined maximum number.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
Lorsqu'il est utilisé comme un argument dans une expression std::bind, les objets d'espace réservé sont stockées dans l'objet de fonction générée, et lorsque cet objet fonction est appelée avec des arguments non liés, chaque _N espace réservé est remplacé par l'argument non liée Nième correspondante .
Original:
When used as an argument in a std::bind expression, the placeholder objects are stored in the generated function object, and when that function object is invoked with unbound arguments, each placeholder _N is replaced by the corresponding Nth unbound argument.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
Les types des objets espace réservé sont DefaultConstructible et CopyConstructible, leur copie par défaut / déplacer les constructeurs ne lèvent pas d'exceptions, et pour tout _N espace réservé, la std::is_placeholder<decltype(_N)> type est défini et est dérivé de std::integral_constant<int, N> .
Original:
The types of the placeholder objects are DefaultConstructible and CopyConstructible, their default copy/move constructors do not throw exceptions, and for any placeholder _N, the type std::is_placeholder<decltype(_N)> is defined and is derived from std::integral_constant<int, N>.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

[modifier] Exemple

Le code suivant illustre la création d'objets de fonction avec un argument espace réservé .
Original:
The following code shows the creation of function objects with a placeholder argument.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

#include <functional>
#include <string>
#include <iostream>
 
void goodbye(const std::string& s)
{
    std::cout << "Goodbye " << s << '\n';
}
 
class Object {
public:
    void hello(const std::string& s)
    {
        std::cout << "Hello " << s << '\n';
    }
};
 
int main(int argc, char* argv[])
{
    typedef std::function<void(const std::string&)> ExampleFunction;
    Object instance;
    std::string str("World");
    ExampleFunction f = std::bind(&Object::hello, &instance, 
                                  std::placeholders::_1);
 
    // equivalent to instance.hello(str)
    f(str);
    f = std::bind(&goodbye, std::placeholders::_1);
 
    // equivalent to goodbye(str)
    f(str);    
    return 0;
}

Résultat :

Hello World
Goodbye World

[modifier] Voir aussi

(C++11)
liaison de paramètres et application partielle d'un foncteur
(fonction générique) [edit]
indique si un objet est un placeholder standard (numéro de paramètre)
(classe générique) [edit]