std::bind_front, std::bind_back

 

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>
std::bind_front
template< class F, class... Args > constexpr /* nicht spezifiziert */ bind_front( F&& f, Args&&... args );	(1)	(seit C++20)
template< auto ConstFn, class... Args > constexpr /* nicht spezifiziert */ bind_front( Args&&... args );	(2)	(seit C++26)
std::bind_back
template< class F, class... Args > constexpr /* nicht spezifiziert */ bind_back( F&& f, Args&&... args );	(3)	(seit C++23)
template< auto ConstFn, class... Args > constexpr /* nicht spezifiziert */ bind_back( Args&&... args );	(4)	(seit C++26)

Die Funktions-Templates std::bind_front und std::bind_back generieren einen "perfect forwarding call wrapper", der es erlaubt, das aufrufbare Ziel mit seinen (1,2) vorderen oder (3,4) hinteren sizeof...(Args) Parametern, die an args gebunden sind, aufzurufen.

1,3) Der Call Wrapper speichert eine Kopie des aufrufbaren Zielobjekts f.

2,4) Der Call Wrapper speichert kein aufrufbares Ziel (dieses ist statisch bestimmt).

1) std::bind_front(f, bound_args...)(call_args...) ist ausdrucksäquivalent zu

std::invoke(f, bound_args..., call_args...).

2) std::bind_front<ConstFn>(bound_args...)(call_args...) ist ausdrucksäquivalent zu

std::invoke(ConstFn, bound_args..., call_args...).

3) std::bind_back(f, bound_args...)(call_args...) ist ausdrucksäquivalent zu

std::invoke(f, call_args..., bound_args...).

4) std::bind_back<ConstFn>(bound_args...)(call_args...) ist ausdrucksäquivalent zu

std::invoke(ConstFn, call_args..., bound_args...).

Die folgenden Bedingungen müssen true sein, andernfalls ist das Programm ill-formed

• (1,3) std::is_constructible_v<std::decay_t<F>, F>,
• (1,3) std::is_move_constructible_v<std::decay_t<F>>,
• (2,4) Wenn decltype(ConstFn) ein Zeiger oder ein Zeiger-auf-Mitglied ist, dann ist ConstFn kein Nullzeiger,
• (std::is_constructible_v<std::decay_t<Args>, Args> && ...),
• (std::is_move_constructible_v<std::decay_t<Args>> && ...).

Parameter

f	-	Callable-Objekt (Funktionsobjekt, Zeiger auf Funktion, Referenz auf Funktion, Zeiger auf Member-Funktion oder Zeiger auf Datenmitglied), das an einige Argumente gebunden werden soll
args	-	Liste der Argumente, die an die (1,2) vorderen oder (3,4) hinteren sizeof...(Args) Parameter des aufrufbaren Ziels gebunden werden sollen
Typanforderungen
- std::decay_t<F> muss die Anforderungen von MoveConstructible erfüllen.
- std::decay_t<Args>... muss die Anforderungen von MoveConstructible erfüllen.
- decltype(ConstFn) muss die Anforderungen von Callable erfüllen.

Rückgabewert

Ein Funktionsobjekt (der Call Wrapper) vom Typ T, das nicht spezifiziert ist, außer dass die Typen der von zwei Aufrufen von std::bind_front oder std::bind_back mit denselben Argumenten zurückgegebenen Objekte gleich sind.

Sei bind-partial entweder std::bind_front oder std::bind_back.

Das zurückgegebene Objekt hat die folgenden Eigenschaften

bind-partial Rückgabetyp

Member-Objekte

Das zurückgegebene Objekt verhält sich so, als ob es enthält

1,3) Ein Member-Objekt fd vom Typ std::decay_t<F>, direkt-nicht-list-initialisiert aus std::forward<F>(f), und

1-4) Ein std::tuple-Objekt tup, konstruiert mit std::tuple<std::decay_t<Args>...>(std::forward<Args>(args)...), außer dass das Verhalten der Zuweisung des zurückgegebenen Objekts nicht spezifiziert ist und die Namen nur zur Veranschaulichung dienen.

Konstruktoren

Der Rückgabetyp von bind-partial verhält sich so, als ob seine Kopier-/Move-Konstruktoren eine elementweise Kopie/Verschiebung durchführen. Er ist CopyConstructible, wenn alle seine Member-Objekte (wie oben angegeben) CopyConstructible sind, und ist andernfalls MoveConstructible.

Member-Funktionsoperator ()

Gegeben sei ein Objekt G, das durch einen früheren Aufruf von (1,3) bind-partial(f, args...) oder (2,4) bind-partial<ConstFn>(args...) erhalten wurde. Wenn ein L-Wert g, der G bezeichnet, in einem Funktionsaufrufausdruck g(call_args...) aufgerufen wird, findet eine Invocierung des gespeicherten Objekts statt, als ob durch:

1) std::invoke(g.fd, std::get<Ns>(g.tup)..., call_args...), wenn bind-partial std::bind_front ist,

2) std::invoke(ConstFn, std::get<Ns>(g.tup)..., call_args...), wenn bind-partial std::bind_front ist,

3) std::invoke(g.fd, call_args..., std::get<Ns>(g.tup)...), wenn bind-partial std::bind_back ist,

4) std::invoke(ConstFn, call_args..., std::get<Ns>(g.tup)...), wenn bind-partial std::bind_back ist,

wobei

• Ns ist ein Integer-Pack 0, 1, ..., (sizeof...(Args) - 1),
• g ist ein L-Wert im std::invoke-Ausdruck, wenn es ein L-Wert im Aufrufausdruck ist, und ansonsten ein R-Wert. Daher kann std::move(g)(call_args...) die gebundenen Argumente in den Aufruf verschieben, während g(call_args...) kopiert.

Das Programm ist ill-formed, wenn g einen volatile-qualifizierten Typ hat.

Der Member operator() ist noexcept, wenn der std::invoke-Ausdruck, den er aufruft, noexcept ist (mit anderen Worten, er behält die Ausnahmespezifikation des zugrundeliegenden Aufrufoperators).

Ausnahmen

1,3) Wirft jede Ausnahme, die beim Aufruf des Konstruktors des gespeicherten Funktionsobjekts geworfen wird.

1-4) Wirft jede Ausnahme, die beim Aufruf des Konstruktors eines der gebundenen Argumente geworfen wird.

Hinweise

Diese Funktions-Templates sind dazu gedacht, std::bind zu ersetzen. Im Gegensatz zu std::bind unterstützen sie keine beliebige Argumentumordnung und haben keine spezielle Behandlung für verschachtelte Bind-Ausdrücke oder std::reference_wrapper. Andererseits achten sie auf die Wertkategorie des Call-Wrapper-Objekts und propagieren die Ausnahmespezifikation des zugrundeliegenden Aufrufoperators.

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

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

Typischerweise erfordert das Binden von Argumenten an eine Funktion oder eine Member-Funktion mithilfe von (1) std::bind_front und (3) std::bind_back das Speichern eines Funktionszeigers zusammen mit den Argumenten, obwohl die Sprache genau weiß, welche Funktion aufgerufen werden soll, ohne dass der Zeiger dereferenziert werden muss. Um "Nullkosten" in diesen Fällen zu garantieren, führt C++26 die Versionen (2,4) ein (die das aufrufbare Objekt als Argument für einen Nicht-Typ-Template-Parameter akzeptieren).

Feature-Test-Makro	Wert	Std	Feature
__cpp_lib_bind_front	201907L	(C++20)	std::bind_front, (1)
	202306L	(C++26)	Erlaubt das Übergeben von aufrufbaren Objekten als Nicht-Typ-Template-Argumente an std::bind_front, (2)
__cpp_lib_bind_back	202202L	(C++23)	std::bind_back, (3)
	202306L	(C++26)	Erlaubt das Übergeben von aufrufbaren Objekten als Nicht-Typ-Template-Argumente an std::bind_back, (4)

Mögliche Implementierung

(2) bind_front
namespace detail { template<class T, class U> struct copy_const : std::conditional<std::is_const_v<T>, U const, U> {};   template<class T, class U, class X = typename copy_const<std::remove_reference_t<T>, U>::type> struct copy_value_category : std::conditional<std::is_lvalue_reference_v<T&&>, X&, X&&> {};   template <class T, class U> struct type_forward_like : copy_value_category<T, std::remove_reference_t<U>> {};   template <class T, class U> using type_forward_like_t = typename type_forward_like<T, U>::type; }   template<auto ConstFn, class... Args> constexpr auto bind_front(Args&&... args) { using F = decltype(ConstFn);   if constexpr (std::is_pointer_v<F> or std::is_member_pointer_v<F>) static_assert(ConstFn != nullptr);   return [... bound_args(std::forward<Args>(args))]<class Self, class... T> ( this Self&&, T&&... call_args ) noexcept ( std::is_nothrow_invocable_v<F, detail::type_forward_like_t<Self, std::decay_t<Args>>..., T...> ) -> std::invoke_result_t<F, detail::type_forward_like_t<Self, std::decay_t<Args>>..., T...> { return std::invoke(ConstFn, std::forward_like<Self>(bound_args)..., std::forward<T>(call_args)...); }; }
(4) bind_back
namespace detail { /* is the same as above */ }   template<auto ConstFn, class... Args> constexpr auto bind_back(Args&&... args) { using F = decltype(ConstFn);   if constexpr (std::is_pointer_v<F> or std::is_member_pointer_v<F>) static_assert(ConstFn != nullptr);   return [... bound_args(std::forward<Args>(args))]<class Self, class... T> ( this Self&&, T&&... call_args ) noexcept ( std::is_nothrow_invocable_v<F, detail::type_forward_like_t<Self, T..., std::decay_t<Args>>...> ) -> std::invoke_result_t<F, detail::type_forward_like_t<Self, T..., std::decay_t<Args>>...> { return std::invoke(ConstFn, std::forward<T>(call_args)..., std::forward_like<Self>(bound_args)...); }; }

Beispiel

Führen Sie diesen Code aus

#include <cassert>
#include <functional>
 
int minus(int a, int b)
{
    return a - b;
}
 
struct S
{
    int val;
    int minus(int arg) const noexcept { return val - arg; }
};
 
int main()
{
    auto fifty_minus = std::bind_front(minus, 50);
    assert(fifty_minus(3) == 47); // equivalent to: minus(50, 3) == 47
 
    auto member_minus = std::bind_front(&S::minus, S{50});
    assert(member_minus(3) == 47); //: S tmp{50}; tmp.minus(3) == 47
 
    // Noexcept-specification is preserved:
    static_assert(!noexcept(fifty_minus(3)));
    static_assert(noexcept(member_minus(3)));
 
    // Binding of a lambda:
    auto plus = [](int a, int b) { return a + b; };
    auto forty_plus = std::bind_front(plus, 40);
    assert(forty_plus(7) == 47); // equivalent to: plus(40, 7) == 47
 
#if __cpp_lib_bind_front >= 202306L
    auto fifty_minus_cpp26 = std::bind_front<minus>(50);
    assert(fifty_minus_cpp26(3) == 47);
 
    auto member_minus_cpp26 = std::bind_front<&S::minus>(S{50});
    assert(member_minus_cpp26(3) == 47);
 
    auto forty_plus_cpp26 = std::bind_front<plus>(40);
    assert(forty_plus(7) == 47);
#endif
 
#if __cpp_lib_bind_back >= 202202L
    auto madd = [](int a, int b, int c) { return a * b + c; };
    auto mul_plus_seven = std::bind_back(madd, 7);
    assert(mul_plus_seven(4, 10) == 47); //: madd(4, 10, 7) == 47
#endif
 
#if __cpp_lib_bind_back >= 202306L
    auto mul_plus_seven_cpp26 = std::bind_back<madd>(7);
    assert(mul_plus_seven_cpp26(4, 10) == 47);
#endif
}

Referenzen

• C++26 Standard (ISO/IEC 14882:2026)

• TBD Function templates bind_front and bind_back [func.bind.partial]

• C++23 Standard (ISO/IEC 14882:2024)

• 22.10.14 Function templates bind_front and bind_back [func.bind.partial]

• C++20 Standard (ISO/IEC 14882:2020)

• 20.14.14 Function template bind_front [func.bind.front]

Siehe auch

bind (C++11)	bindet ein oder mehrere Argumente an ein Funktions-Objekt (Funktions-Template)
mem_fn (C++11)	erstellt ein Funktions-Objekt aus einem Zeiger auf ein Member (Funktions-Template)