std::placeholders::_1, std::placeholders::_2, ..., std::placeholders::_N
| Défini dans l'en-tête <functional>
|
||
/* see below */ _1;
/* see below */ _2;
.
.
/* see below */ _N;
|
||
L'espace de noms std::placeholders contient les objets d'espace réservé [_1, ..., _N] où N est un nombre maximum défini par l'implémentation.
Lorsqu'ils sont utilisés comme argument dans une expression std::bind, les objets d'espace réservé sont stockés dans l'objet fonction généré, et lorsque cet objet fonction est invoqué avec des arguments non liés, chaque espace réservé _N est remplacé par le Nième argument non lié correspondant.
|
Chaque espace réservé est déclaré comme si par |
(jusqu'à C++17) |
|
Il est encouragé que les implémentations déclarent les espaces réservés comme si par |
(depuis C++17) |
Les types des objets d'espace réservé sont DefaultConstructible et CopyConstructible, leurs constructeurs par défaut/copie/déplacement ne lèvent pas d'exceptions, et pour tout espace réservé _N, le type std::is_placeholder<decltype(_N)> est défini, où std::is_placeholder<decltype(_N)> est dérivé de std::integral_constant<int, N>.
Exemple
Le code suivant montre la création d'objets fonction avec des arguments d'espace réservé.
#include <functional> #include <iostream> #include <string> 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() { using namespace std::placeholders; using ExampleFunction = std::function<void(const std::string&)>; Object instance; std::string str("World"); ExampleFunction f = std::bind(&Object::hello, &instance, _1); f(str); // équivalent à instance.hello(str) f = std::bind(&goodbye, std::placeholders::_1); f(str); // équivalent à goodbye(str) auto lambda = [](std::string pre, char o, int rep, std::string post) { std::cout << pre; while (rep-- > 0) std::cout << o; std::cout << post << '\n'; }; // liaison de la lambda : std::function<void(std::string, char, int, std::string)> g = std::bind(&decltype(lambda)::operator(), &lambda, _1, _2, _3, _4); g("G", 'o', 'o'-'g', "gol"); }
Sortie :
Hello World Goodbye World Goooooooogol
Voir aussi
|
(C++11)
|
lie un ou plusieurs arguments à un objet fonction
(modèle de fonction) |
|
(C++11)
|
indique qu'un objet est un espace réservé standard ou peut être utilisé comme tel
(modèle de classe) |
|
(C++11)
|
espace réservé pour ignorer un élément lors du déballage d'un
tuple
en utilisant
tie
(constante) |