Namensräume
Varianten

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

    Aus cppreference.com
    See More

    This page has been machine-translated from the English version of the wiki using Google Translate.

    The translation may contain errors and awkward wording. Hover over text to see the original version. You can help to fix errors and improve the translation. For instructions click here.

    Click here for the English version of this page

    <metanoindex/>

     
    C++
     
    Utilities-Bibliothek
     
    Function-Objekte
    Funktionswrapper
    function(C++11)
    mem_fn(C++11)
    bad_function_call(C++11)
    Bindung
    bind(C++11)
    is_bind_expression(C++11)
    is_placeholder(C++11)
    _1, _2, _3, ...(C++11)
    Referenzwrapper
    reference_wrapper(C++11)
    ref
    cref    		(C++11)
    (C++11)
    Operatorwrapper
    Verneinung
    Veraltete Binder und Adapter
    unary_function(veraltet)
    binary_function(veraltet)
    ptr_fun(veraltet)
    pointer_to_unary_function(veraltet)
    pointer_to_binary_function(veraltet)
    mem_fun(veraltet)
    mem_fun_t
    mem_fun1_t
    const_mem_fun_t
    const_mem_fun1_t    		(veraltet)
    (veraltet)
    (veraltet)
    (veraltet)
    mem_fun_ref(veraltet)
    mem_fun_ref_t
    mem_fun1_ref_t
    const_mem_fun_ref_t
    const_mem_fun1_ref_t    		(veraltet)
    (veraltet)
    (veraltet)
    (veraltet)
    binder1st
    binder2nd    		(veraltet)
    (veraltet)
    bind1st
    bind2nd    		(veraltet)
    (veraltet)
     
    <tbody> </tbody>
    definiert in Header <functional>
    extern /*unspecified*/ _1; extern /*unspecified*/ _2; . . extern /*unspecified*/ _N;
    Die std::placeholders Namespace enthält die Platzhalterobjekte [_1, . . . _N] wo N ist eine Implementierung definierte maximale Anzahl .
    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.
    Wenn als Argument in einer std::bind Ausdruck verwendet wird, werden die Platzhalter Objekte in der generierten Funktions-Objekt gespeichert, und wenn diese Funktion Objekt mit ungebundenen Argumente aufgerufen wird, jeder Platzhalter _N wird durch die entsprechende Nth ungebundenen Argument ersetzt .
    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.
    Die Typen der Platzhalter Objekte sind DefaultConstructible und CopyConstructible, ihre Standardwerte copy / move Konstruktoren keine Ausnahmen, und für jeden Platzhalter _N, die Art std::is_placeholder<decltype(_N)> definiert und wird von std::integral_constant<int, N> abgeleitet .
    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.

    Beispiel

    Der folgende Code zeigt die Erstellung von Funktions-Objekte mit einem Platzhalter Argument .
    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;
}

    Output: 

    Hello World
Goodbye World

    Siehe auch

    (C++11)
    bindet ein oder mehrere Argumente an eine Funktion Objekt
    Original:
    binds one or more arguments to a function object
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.

    (Funktions-Template) [edit]
    (C++11)
    zeigt an, dass ein Objekt ein Standard Platzhalter ist oder wie ein eingesetzt werden
    Original:
    indicates that an object is a standard placeholder or can be used as one
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.

    (Klassen-Template) [edit]