Namespaces
Variants

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

    Von de.cppreference.net
     
    C++
     
    Hilfsprogramm-Bibliothek
    Sprachunterstützung
    Typunterstützung (Basistypen, RTTI)
    Bibliotheks-Feature-Test-Makros (C++20)
    Programm-Hilfsprogramme
    Variadische Funktionen
    (C++11)
    (C++20)
    (C++26)
    (C++20)
    Koroutinenunterstützung (C++20)
    Vertragsunterstützung (C++26)
    Dreiseitiger Vergleich
    (C++20)(C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)    
    (C++20)(C++20)(C++20)    
    (C++20)(C++20)(C++20)

    Allgemeine Hilfsprogramme
    Vergleichsoperatoren (veraltet in C++20)
    Ganzzahlvergleichsfunktionen
    (C++20)(C++20)(C++20)    
    (C++20)
    Tausch und Typoperationen
    (C++20)
    (C++14)
    (C++11)
    (C++23)
    (C++11)
    (C++23)
    (C++11)
    (C++11)
    (C++17)
    Allgemeine Vokabular-Typen
    (C++11)
    (C++17)
    (C++17)
    (C++17)
    (C++11)
    (C++11)
    (C++17)
    (C++17)
    (C++23)



     
    Funktionsobjekte
    Funktionsaufruf
    (C++17)(C++23)
    Identitätsfunktionsobjekt
    (C++20)
    Transparente Operator-Wrapper
    (C++14)
    (C++14)
    (C++14)
    (C++14)  
    (C++14)
    (C++14)
    (C++14)
    (C++14)
    (C++14)
    (C++14)
    (C++14)
    (C++14)
    (C++14)
    (C++14)
    (C++14)
    (C++14)
    (C++14)
    (C++14)
    (C++14)

    Alte Binder und Adaptoren
    (bis C++17*)
    (bis C++17*)
    (bis C++17*)
    (bis C++17*)
    (bis C++17*)  
    (bis C++17*)
    (bis C++17*)(bis C++17*)(bis C++17*)(bis C++17*)
    (bis C++20*)
    (bis C++20*)
    (bis C++17*)(bis C++17*)
    (bis C++17*)(bis C++17*)

    (bis C++17*)
    (bis C++17*)(bis C++17*)(bis C++17*)(bis C++17*)
    (bis C++20*)
    (bis C++20*)
     
    Definiert in Header <functional> 
    /* see below */ _1;
/* see below */ _2;
.
.
/* see below */ _N;

    Der Namespace std::placeholders enthält die Platzhalterobjekte [_1, ..., _N], wobei N eine implementationsdefinierte maximale Anzahl ist.

    Wenn sie als Argument in einem std::bind-Ausdruck verwendet werden, werden die Platzhalterobjekte im erzeugten Funktionsobjekt gespeichert, und wenn dieses Funktionsobjekt mit ungebundenen Argumenten aufgerufen wird, wird jeder Platzhalter _N durch das entsprechende N-te ungebundene Argument ersetzt.

    Jeder Platzhalter wird deklariert, als ob durch extern /* unspecified */ _1;.

    		(bis C++17)

    Implementierungen werden ermutigt, die Platzhalter zu deklarieren, als ob durch inline constexpr /* unspecified */ _1;, obwohl die Deklaration durch extern /* unspecified */ _1; vom Standard immer noch erlaubt ist.

    		(seit C++17)

    Die Typen der Platzhalterobjekte sind DefaultConstructible und CopyConstructible, ihre Standard-Kopier-/Verschiebekonstruktoren werfen keine Ausnahmen, und für jeden Platzhalter _N ist der Typ std::is_placeholder<decltype(_N)> definiert, wobei std::is_placeholder<decltype(_N)> von std::integral_constant<int, N> abgeleitet ist.

    Beispiel

    Der folgende Code zeigt die Erstellung von Funktionsobjekten mit Platzhalterargumenten.

    Diesen Code ausführen 
    #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); // equivalent to instance.hello(str)
    f = std::bind(&goodbye, std::placeholders::_1);
    f(str); // equivalent to 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';
    };
    // binding the 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");
}

    Ausgabe: 

    Hello World
Goodbye World
Goooooooogol

    Siehe auch

    (C++11)
    		bindet ein oder mehrere Argumente an ein Funktionsobjekt
    (Funktions-Template)
    (C++11)
    		zeigt an, dass ein Objekt ein Standard-Platzhalter ist oder als solcher verwendet werden kann
    (Klassen-Template)
    (C++11)
    		Platzhalter zum Überspringen eines Elements beim Auspacken eines tuple mittels tie
    (Konstante)