std::bind

 

C++

Compiler-Unterstützung

Freestanding und gehostet

Sprache

Standardbibliothek

Header der Standardbibliothek

Benannte Anforderungen

Feature-Test-Makros (C++20)

Bibliothek für Sprachunterstützung

Konzepte-Bibliothek (C++20)

Diagnostik-Bibliothek

Speicherverwaltungsbibliothek

Metaprogrammierungsbibliothek (C++11)

Allgemeine Dienstprogramme-Bibliothek

Container-Bibliothek

Iterator-Bibliothek

Ranges-Bibliothek (C++20)

Algorithmen-Bibliothek

Bibliothek für Zeichenketten

Textverarbeitungsbibliothek

Numerik-Bibliothek

Datums- und Zeitbibliothek

Ein-/Ausgabe-Bibliothek

Dateisystembibliothek (C++17)

Unterstützung für nebenläufige Programmierung (C++11)

Ausführungssteuerungsbibliothek (C++26)

Technische Spezifikationen

Symbolverzeichnis

Externe Bibliotheken

 

Dienstprogramm-Bibliotheken

Sprachunterstützung Typunterstützung (Basistypen, RTTI) Bibliotheks-Feature-Test-Makros (C++20) Programm-Dienstprogramme Variadische Funktionen initializer_list (C++11) is_constant_evaluated (C++20) is_within_lifetime (C++26) source_location (C++20) Coroutine-Unterstützung (C++20) Vertragsunterstützung (C++26) Drei-Wege-Vergleich three_way_comparablethree_way_comparable_with (C++20)(C++20) strong_ordering (C++20) weak_ordering (C++20) partial_ordering (C++20) common_comparison_category (C++20) compare_three_way_result (C++20) compare_three_way (C++20) strong_order (C++20) weak_order (C++20) partial_order (C++20) compare_strong_order_fallback (C++20) compare_weak_order_fallback (C++20) compare_partial_order_fallback (C++20)   is_eqis_ltis_lteq (C++20)(C++20)(C++20)   is_neqis_gtis_gteq (C++20)(C++20)(C++20)

Allgemeine Hilfsmittel Funktionsobjekte Bit-Manipulation (C++20) bitset hash (C++11) Relationale Operatoren (in C++20 veraltet) rel_ops::operator!=rel_ops::operator>    rel_ops::operator<=rel_ops::operator>= Ganzzahl-Vergleichsfunktionen cmp_equalcmp_lesscmp_less_than (C++20)(C++20)(C++20)   cmp_not_equalcmp_greatercmp_greater_than (C++20)(C++20)(C++20) in_range (C++20) Swap und Typ-Operationen swap ranges::swap (C++20) exchange (C++14) declval (C++11) to_underlying (C++23) forward (C++11) forward_like (C++23) move (C++11) move_if_noexcept (C++11) as_const (C++17) Gemeinsame Vokabulartypen pair tuple (C++11) optional (C++17) any (C++17) variant (C++17) tuple_size (C++11) tuple_element (C++11) apply (C++17) make_from_tuple (C++17) expected (C++23)

 

Funktionsobjekte

Funktions-Wrapper Funktion (C++11) move_only_function (C++23) copyable_function (C++26) function_ref (C++26) mem_fn (C++11) bad_function_call (C++11)	Partielle Funktionsanwendung bind_frontbind_back (C++20)(C++23) bind (C++11) is_bind_expression (C++11) is_placeholder (C++11) _1, _2, _3, ... (C++11)
Funktionsaufruf invokeinvoke_r (C++17)(C++23) Identitätsfunktions-Objekt identity (C++20)	Referenz-Wrapper reference_wrapper (C++11) refcref (C++11)(C++11) unwrap_referenceunwrap_ref_decay (C++20)(C++20)
Operator-Wrapper plus minus negate multiplies divides modulus bit_and bit_or bit_not (C++14)   bit_xor equal_to not_equal_to greater less greater_equal less_equal logical_and logical_or logical_not	Transparente Operator-Wrapper plus<> (C++14) minus<> (C++14) negate<> (C++14) multiplies<> (C++14)   divides<> (C++14) modulus<> (C++14) bit_and<> (C++14) bit_or<> (C++14) bit_not<> (C++14) bit_xor<> (C++14) equal_to<> (C++14) not_equal_to<> (C++14) greater<> (C++14) less<> (C++14) greater_equal<> (C++14) less_equal<> (C++14) logical_and<> (C++14) logical_or<> (C++14) logical_not<> (C++14)
Negatoren not_fn (C++17) Sucher default_searcher (C++17) boyer_moore_searcher (C++17) boyer_moore_horspool_searcher (C++17)	Beschränkte Komparatoren ranges::equal_to (C++20) ranges::not_equal_to (C++20) ranges::greater (C++20) ranges::less (C++20) ranges::greater_equal (C++20) ranges::less_equal (C++20) compare_three_way (C++20)
Alte Binder und Adaptoren
unary_function (bis C++17*) binary_function (bis C++17*) ptr_fun (bis C++17*) pointer_to_unary_function (bis C++17*) pointer_to_binary_function (bis C++17*)   mem_fun (bis C++17*) mem_fun_tmem_fun1_tconst_mem_fun_tconst_mem_fun1_t (bis C++17*)(bis C++17*)(bis C++17*)(bis C++17*) not1 (bis C++20*) not2 (bis C++20*)	binder1stbinder2nd (bis C++17*)(bis C++17*) bind1stbind2nd (bis C++17*)(bis C++17*) mem_fun_ref (bis C++17*) mem_fun_ref_tmem_fun1_ref_tconst_mem_fun_ref_tconst_mem_fun1_ref_t (bis C++17*)(bis C++17*)(bis C++17*)(bis C++17*) unary_negate (bis C++20*) binary_negate (bis C++20*)

 

Definiert in der Header-Datei <functional>
template< class F, class... Args > /* unspecified */ bind( F&& f, Args&&... args );	(1)	(seit C++11) (constexpr seit C++20)
template< class R, class F, class... Args > /* unspecified */ bind( F&& f, Args&&... args );	(2)	(seit C++11) (constexpr seit C++20)

Die Funktionvorlage std::bind generiert einen Weiterleitungsaufruf-Wrapper für f. Das Aufrufen dieses Wrappers entspricht dem Aufrufen von f mit einigen seiner Argumente, die an args gebunden sind.

Wenn std::is_constructible<std::decay<F>::type, F>::value false ist oder std::is_constructible<std::decay<Arg_i>::type, Arg_i>::value für einen Typ Arg_i in Args false ist, ist das Programm schlecht geformt.

Wenn std::decay<Ti>::type oder ein Typ in Args nicht MoveConstructible oder Destructible ist, ist das Verhalten undefiniert.

Parameter

f	-	Aufrufbares Objekt (Funktionsobjekt, Zeiger auf Funktion, Referenz auf Funktion, Zeiger auf Mitgliedsfunktion oder Zeiger auf Datenmitglied), das an einige Argumente gebunden wird
args	-	Liste von Argumenten, die gebunden werden sollen, wobei die ungebundenen Argumente durch die Platzhalter _1, _2, _3... im Namensraum std::placeholders ersetzt werden

Rückgabewert

Ein Funktionsobjekt g eines nicht spezifizierten Typs T, für das std::is_bind_expression<T>::value true ist. Es hat die folgenden Mitglieder:

std::bind Rückgabetyp

Member-Objekte

Der Rückgabetyp von std::bind enthält ein Mitgliedsobjekt vom Typ std::decay<F>::type, konstruiert aus std::forward<F>(f), und ein Objekt für jedes der Argumente args... vom Typ std::decay<Arg_i>::type, ähnlich konstruiert aus std::forward<Arg_i>(arg_i).

Konstruktoren

Der Rückgabetyp von std::bind ist CopyConstructible, wenn alle seine Mitgliedsobjekte (wie oben angegeben) CopyConstructible sind, und andernfalls MoveConstructible. Der Typ definiert die folgenden Mitglieder:

Mitgliedstyp result_type 1) (in C++17 veraltet) Wenn F ein Zeiger auf eine Funktion oder ein Zeiger auf eine Mitgliedsfunktion ist, ist result_type der Rückgabetyp von F. Wenn F ein Klassentyp mit der verschachtelten Typedef result_type ist, dann ist result_type F::result_type. Andernfalls ist kein result_type definiert. 2) (in C++17 veraltet) result_type ist exakt R.

(bis C++20)

Member-Funktionsoperator ()

Wenn g in einem Funktionsaufruf-Ausdruck g(u1, u2, ... uM) aufgerufen wird, findet ein Aufruf des gespeicherten Objekts statt, als ob durch:

1) INVOKE(fd, std::forward<V1>(v1), std::forward<V2>(v2), ..., std::forward<VN>(vN)) oder

2) INVOKE<R>(fd, std::forward<V1>(v1), std::forward<V2>(v2), ..., std::forward<VN>(vN)),

wobei fd ein Wert vom Typ std::decay<F>::type ist, die Werte und Typen der gebundenen Argumente v1, v2, ..., vN gemäß der Spezifikation unten bestimmt werden.

Wenn einige der Argumente, die im Aufruf an g() übergeben werden, nicht durch Platzhalter in g abgedeckt werden, werden die ungenutzten Argumente ausgewertet und verworfen.

Ein Aufruf von operator() ist nicht auslösend oder ist ein konstanter Teilausdruck(seit C++20), wenn und nur wenn der zugrunde liegende INVOKE-Vorgang nicht auslösend ist. operator() nimmt nur an der Auflösung von Überladungen teil, wenn der INVOKE-Vorgang als nicht ausgewerteter Operand wohlgeformt ist.

Wenn g volatile-qualifiziert ist, ist das Programm schlecht geformt.

Wenn INVOKE(fd, w1, w2, ..., wN) niemals ein gültiger Ausdruck für beliebige mögliche Werte w1, w2, ..., wN sein kann, ist das Verhalten undefiniert.

Gebundene Argumente

Für jedes gespeicherte Argument arg_i wird das entsprechende gebundene Argument v_i im INVOKE- oder INVOKE<R>-Vorgang wie folgt bestimmt:

Fall 1: Referenz-Wrapper

Wenn arg_i vom Typ std::reference_wrapper<T> ist (z. B. wenn std::ref oder std::cref im ursprünglichen Aufruf von std::bind verwendet wurde), dann ist v_i arg_i.get() und sein Typ V_i ist T&: Das gespeicherte Argument wird per Referenz an das aufgerufene Funktionsobjekt übergeben.

Fall 2: Bind-Ausdrücke

Wenn arg_i vom Typ T ist, für den std::is_bind_expression<T>::value true ist (z. B. ein weiterer std::bind-Ausdruck wurde direkt in den ursprünglichen Aufruf von std::bind übergeben), dann führt std::bind eine Funktionskomposition durch: Anstatt das Funktionsobjekt zurückzugeben, das der Bind-Teilausdruck zurückgeben würde, wird der Teilausdruck sofort aufgerufen und sein Rückgabewert an das äußere aufrufbare Objekt übergeben. Wenn der Bind-Teilausdruck Platzhalterargumente hat, werden diese mit dem äußeren Bind geteilt (aus u1, u2, ... ausgewählt). Insbesondere ist v_i arg_i(std::forward<Uj>(uj)...) und sein Typ V_i ist std::result_of<T cv &(Uj&&...)>::type&&(bis C++17)std::invoke_result_t<T cv &, Uj&&...>&&(seit C++17) (Die cv-Qualifikation ist dieselbe wie bei g).

Fall 3: Platzhalter

Wenn arg_i vom Typ T ist, für den std::is_placeholder<T>::value nicht ​0​ ist (d. h., ein Platzhalter wie std::placeholders::_1, _2, _3, ... wurde als Argument für den ursprünglichen Aufruf von std::bind verwendet), dann wird das durch den Platzhalter angezeigte Argument (u1 für _1, u2 für _2 usw.) an das aufrufbare Objekt übergeben: v_i ist std::forward<Uj>(uj) und sein Typ V_i ist Uj&&.

Fall 4: Gewöhnliche Argumente

Andernfalls wird arg_i als lvalue-Argument an das aufrufbare Objekt übergeben: v_i ist einfach arg_i und sein Typ V_i ist T cv &, wobei cv dieselbe cv-Qualifikation wie die von g ist.

Ausnahmen

Wirft nur, wenn die Konstruktion von std::decay<F>::type aus std::forward<F>(f) wirft, oder wenn einer der Konstruktoren für std::decay<Arg_i>::type aus dem entsprechenden std::forward<Arg_i>(arg_i) wirft, wobei Arg_i der i-te Typ und arg_i das i-te Argument in Args... args ist.

Hinweise

Wie in Callable beschrieben, muss beim Aufrufen eines Zeigers auf eine nicht-statische Mitgliedsfunktion oder eines Zeigers auf ein nicht-statisches Datenmitglied das erste Argument eine Referenz oder ein Zeiger (einschließlich möglicherweise eines Smart Pointers wie std::shared_ptr und std::unique_ptr) auf ein Objekt sein, dessen Mitglied zugegriffen werden soll.

Die Argumente für bind werden kopiert oder verschoben und niemals per Referenz übergeben, es sei denn, sie sind in std::ref oder std::cref verpackt.

Doppelte Platzhalter im selben Bind-Ausdruck (z. B. mehrere _1) sind zulässig, aber die Ergebnisse sind nur dann wohldefiniert, wenn das entsprechende Argument (u1) ein lvalue oder ein nicht verschiebbares rvalue ist.

Beispiel

Führen Sie diesen Code aus

#include <functional>
#include <iostream>
#include <memory>
#include <random>
 
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;  // for _1, _2, _3...
 
    std::cout << "1) argument reordering and pass-by-reference: ";
    int n = 7;
    // (_1 and _2 are from std::placeholders, and represent future
    // arguments that will be passed to f1)
    auto f1 = std::bind(f, _2, 42, _1, std::cref(n), n);
    n = 10;
    f1(1, 2, 1001); // 1 is bound by _1, 2 is bound by _2, 1001 is unused
                    // makes a call to f(2, 42, 1, n, 7)
 
    std::cout << "2) achieving the same effect using a lambda: ";
    n = 7;
    auto lambda = [&ncref = n, n](auto a, auto b, auto /*unused*/)
    {
        f(b, 42, a, ncref, n);
    };
    n = 10;
    lambda(1, 2, 1001); // same as a call to f1(1, 2, 1001)
 
    std::cout << "3) nested bind subexpressions share the placeholders: ";
    auto f2 = std::bind(f, _3, std::bind(g, _3), _3, 4, 5);
    f2(10, 11, 12); // makes a call to f(12, g(12), 12, 4, 5);
 
    std::cout << "4) bind a RNG with a distribution: ";
    std::default_random_engine e;
    std::uniform_int_distribution<> d(0, 10);
    auto rnd = std::bind(d, e); // a copy of e is stored in rnd
    for (int n = 0; n < 10; ++n)
        std::cout << rnd() << ' ';
    std::cout << '\n';
 
    std::cout << "5) bind to a pointer to member function: ";
    Foo foo;
    auto f3 = std::bind(&Foo::print_sum, &foo, 95, _1);
    f3(5);
 
    std::cout << "6) bind to a mem_fn that is a pointer to member function: ";
    auto ptr_to_print_sum = std::mem_fn(&Foo::print_sum);
    auto f4 = std::bind(ptr_to_print_sum, &foo, 95, _1);
    f4(5);
 
    std::cout << "7) bind to a pointer to data member: ";
    auto f5 = std::bind(&Foo::data, _1);
    std::cout << f5(foo) << '\n';
 
    std::cout << "8) bind to a mem_fn that is a pointer to data member: ";
    auto ptr_to_data = std::mem_fn(&Foo::data);
    auto f6 = std::bind(ptr_to_data, _1);
    std::cout << f6(foo) << '\n';
 
    std::cout << "9) use smart pointers to call members of the referenced objects: ";
    std::cout << f6(std::make_shared<Foo>(foo)) << ' '
              << f6(std::make_unique<Foo>(foo)) << '\n';
}

Ausgabe

1) argument reordering and pass-by-reference: 2 42 1 10 7
2) achieving the same effect using a lambda: 2 42 1 10 7
3) nested bind subexpressions share the placeholders: 12 12 12 4 5
4) bind a RNG with a distribution: 0 1 8 5 5 2 0 7 7 10 
5) bind to a pointer to member function: 100
6) bind to a mem_fn that is a pointer to member function: 100
7) bind to a pointer to data member: 10
8) bind to a mem_fn that is a pointer to data member: 10
9) use smart pointers to call members of the referenced objects: 10 10

Fehlermeldungen

Die folgenden Verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

DR	angewendet auf	Verhalten wie veröffentlicht	Korrigiertes Verhalten
LWG 2021	C++11	1. die gebundenen Argumente     wurden nicht an fd weitergeleitet 2. im Fall 2 war der Typ von V_i     std::result_of<T cv (Uj...)>::type	1. weitergeleitet 2. geändert zu     std::result_of<T cv &(Uj&&...)>::type&&

Siehe auch

bind_frontbind_back (C++20)(C++23)	bindet eine variable Anzahl von Argumenten, in Reihenfolge, an ein Funktions-Objekt (Funktions-Template)
_1, _2, _3, _4, ... (C++11)	Platzhalter für die ungebundenen Argumente in einem std::bind-Ausdruck (Konstante)
mem_fn (C++11)	erstellt ein Funktions-Objekt aus einem Zeiger auf ein Member (Funktions-Template)