Funktionsobjekte

 

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*)

 

Ein Funktions-Objekt ist jedes Objekt, für das der Funktionsaufruf-Operator definiert ist. C++ stellt viele eingebaute Funktions-Objekte sowie Unterstützung für die Erstellung und Manipulation neuer Funktions-Objekte bereit.

Funktionsaufruf

Die expositions-nur Operation INVOKE(f, arg_0, arg_1, arg_2, ..., arg_N) ist wie folgt definiert Sei Typ Obj der unveränderte Typ von arg_0 (d.h. std::remove_cv<std::remove_reference<decltype(arg_0)>::type>::type) Wenn f ein Zeiger auf eine Memberfunktion der Klasse C ist, dann ist INVOKE(f, obj, arg_1, arg_2, ..., arg_N) äquivalent zu Wenn std::is_same<C, Obj>::value || std::is_base_of<C, Obj>::value true ist (obj.*f)(arg_1, arg_2, ..., arg_N) (Aufruf der Memberfunktion auf dem Objekt). Wenn Obj eine Spezialisierung von std::reference_wrapper ist (obj.get().*f)(arg_1, arg_2, ..., arg_N) (Aufruf der Memberfunktion auf dem speziell referenzierten Objekt). Andernfalls ((*obj).*f)(arg_1, arg_2, ..., arg_N) (Aufruf der Memberfunktion auf dem dereferenzierten Objekt). Andernfalls, wenn N == 0 und f ein Zeiger auf ein Datenmember der Klasse C ist, dann ist INVOKE(mptr, obj) äquivalent zu Wenn std::is_same<C, Obj>::value || std::is_base_of<C, Obj>::value true ist obj.*mptr (Zugriff auf das Datenmember des Objekts). Wenn Obj eine Spezialisierung von std::reference_wrapper ist obj.get().*mptr (Zugriff auf das Datenmember des speziell referenzierten Objekts). Andernfalls (*obj).*mptr (Zugriff auf das Datenmember des dereferenzierten Objekts). Andernfalls INVOKE(f, arg_0, arg_1, arg_2, ..., arg_N) ist äquivalent zu f(arg_0, arg_1, arg_2, ..., arg_N) (Aufruf des aufrufbaren Objekts). Die expositions-nur Operation INVOKE<R>(f, arg_0, arg_1, arg_2, ..., arg_N) ist wie folgt definiert Wenn R (möglicherweise cv-qualifiziert) void ist static_cast<void>(INVOKE(f, arg_0, arg_1, arg_2, ..., arg_N)). Andernfalls INVOKE(f, arg_0, arg_1, arg_2, ..., arg_N) implizit konvertiert zu R. Sei Typ Actual decltype(INVOKE(f, arg_0, arg_1, arg_2, ..., arg_N)) Wenn std::reference_converts_from_temporary_v <R, Actual> true ist INVOKE<R>(f, arg_0, arg_1, arg_2, ..., arg_N) ist ill-formed. (seit C++23)

(seit C++11)

std::invoke und std::invoke_r(seit C++23) können jedes Callable-Objekt mit gegebenen Argumenten gemäß den Regeln von INVOKE und INVOKE<R>(seit C++23) aufrufen.

invokeinvoke_r (C++17)(C++23)

ruft jedes Callable-Objekt mit gegebenen Argumenten auf und der Möglichkeit, den Rückgabetyp anzugeben(seit C++23) (Funktions-Template)

Funktions-Wrapper

Diese polymorphen Wrapper-Klassen bieten Unterstützung für die Speicherung beliebiger Funktions-Objekte.

Funktion (C++11)	kopierfähiger Wrapper für jedes kopierkonstruierbare aufrufbare Objekt (Klassen-Template)
move_only_function (C++23)	Move-only-Wrapper für jedes aufrufbare Objekt, das Qualifizierer in einer gegebenen Aufrufsignatur unterstützt (Klassen-Template)
copyable_function (C++26)	kopierfähiger Wrapper für jedes kopierkonstruierbare aufrufbare Objekt, das Qualifizierer in einer gegebenen Aufrufsignatur unterstützt (Klassen-Template)
function_ref (C++26)	nicht-besitzender Wrapper für jedes aufrufbare Objekt (Klassen-Template)
bad_function_call (C++11)	die Ausnahme, die beim Aufruf einer leeren std::function ausgelöst wird (Klasse)
mem_fn (C++11)	erstellt ein Funktions-Objekt aus einem Zeiger auf ein Member (Funktions-Template)

Identität

std::identity ist das Identitätsfunktions-Objekt: es gibt sein Argument unverändert zurück.

identity (C++20)

Funktions-Objekt, das sein Argument unverändert zurückgibt (Klasse)

Partielle Funktionsanwendung

std::bind_front und std::bind bieten Unterstützung für die partielle Funktionsanwendung, d.h. das Binden von Argumenten an Funktionen zur Erzeugung neuer Funktionen.

bind_frontbind_back (C++20)(C++23)	bindet eine variable Anzahl von Argumenten, in Reihenfolge, an ein Funktions-Objekt (Funktions-Template)
bind (C++11)	bindet ein oder mehrere Argumente an ein Funktions-Objekt (Funktions-Template)
is_bind_expression (C++11)	zeigt an, dass ein Objekt ein std::bind-Ausdruck ist oder als solcher verwendet werden kann (Klassen-Template)
is_placeholder (C++11)	zeigt an, dass ein Objekt ein Standard-Platzhalter ist oder als solcher verwendet werden kann (Klassen-Template)
Definiert im Namespace std::placeholders
_1, _2, _3, _4, ... (C++11)	Platzhalter für die ungebundenen Argumente in einem std::bind-Ausdruck (Konstante)

Negatoren

std::not_fn erstellt ein Funktions-Objekt, das das Ergebnis des übergebenen aufrufbaren Objekts negiert.

not_fn (C++17)

erstellt ein Funktions-Objekt, das das Komplement des Ergebnisses des gehaltenen Funktions-Objekts zurückgibt (Funktions-Template)

Sucher

Sucher, die mehrere Zeichenketten-Suchalgorithmen implementieren, werden bereitgestellt und können entweder direkt oder mit std::search verwendet werden.

default_searcher (C++17)	Implementierung des standardmäßigen C++-Bibliotheks-Suchalgorithmus (Klassen-Template)
boyer_moore_searcher (C++17)	Implementierung des Boyer-Moore-Suchalgorithmus (Klassen-Template)
boyer_moore_horspool_searcher (C++17)	Implementierung des Boyer-Moore-Horspool-Suchalgorithmus (Klassen-Template)

Referenz-Wrapper

Referenz-Wrapper ermöglichen die Speicherung von Referenzargumenten in kopierfähigen Funktions-Objekten

reference_wrapper (C++11)	CopyConstructible und CopyAssignable Referenz-Wrapper (Klassen-Template)
refcref (C++11)(C++11)	erstellt einen std::reference_wrapper, wobei der Typ aus seinem Argument abgeleitet wird (Funktions-Template)
unwrap_referenceunwrap_ref_decay (C++20)(C++20)	holt den Referenztyp, der in std::reference_wrapper eingepackt ist (Klassen-Template)

Transparente Funktions-Objekte Assoziative Container und ungeordnete assoziative Container(seit C++20) bieten heterogene Lookups und Löschoperationen(seit C++23), aber diese sind nur dann aktiviert, wenn der angegebene Funktions-Objekt-Typ T transparent ist: Der qualifizierte Bezeichner T::is_transparent ist gültig und bezeichnet einen Typ. Alle transparenten Funktions-Objekt-Typen in der Standardbibliothek definieren einen verschachtelten Typ is_transparent. Benutzerdefinierte transparente Funktions-Objekt-Typen müssen is_transparent jedoch nicht direkt als verschachtelten Typ bereitstellen: er kann in einer Basisklasse definiert sein, solange T::is_transparent die oben genannte transparente Anforderung erfüllt.

(seit C++14)

Operator-Funktions-Objekte

C++ definiert die folgenden Funktions-Objekte, die gängige arithmetische und logische Operationen darstellen.

Die void-Spezialisierungen leiten ihre Parameter- und Rückgabetypen von ihren Argumenten ab, sie sind alle transparent.

(seit C++14)

Arithmetische Operationen
plus	Funktions-Objekt, das x + y implementiert (Klassen-Template)
plus<void> (C++14)	Funktions-Objekt, das x + y implementiert und Parameter- und Rückgabetypen ableitet (Klassen-Template-Spezialisierung)
minus	Funktions-Objekt, das x - y implementiert (Klassen-Template)
minus<void> (C++14)	Funktions-Objekt, das x - y implementiert und Parameter- und Rückgabetypen ableitet (Klassen-Template-Spezialisierung)
multiplies	Funktions-Objekt, das x * y implementiert (Klassen-Template)
multiplies<void> (C++14)	Funktions-Objekt, das x * y implementiert und Parameter- und Rückgabetypen ableitet (Klassen-Template-Spezialisierung)
divides	Funktions-Objekt, das x / y implementiert (Klassen-Template)
divides<void> (C++14)	Funktions-Objekt, das x / y implementiert und Parameter- und Rückgabetypen ableitet (Klassen-Template-Spezialisierung)
modulus	Funktions-Objekt, das x % y implementiert (Klassen-Template)
modulus<void> (C++14)	Funktions-Objekt, das x % y implementiert und Parameter- und Rückgabetypen ableitet (Klassen-Template-Spezialisierung)
negate	Funktions-Objekt, das -x implementiert (Klassen-Template)
negate<void> (C++14)	Funktions-Objekt, das -x implementiert und Parameter- und Rückgabetypen ableitet (Klassen-Template-Spezialisierung)
Vergleiche
equal_to	Funktions-Objekt, das x == y implementiert (Klassen-Template)
equal_to<void> (C++14)	Funktions-Objekt, das x == y implementiert und Parameter- und Rückgabetypen ableitet (Klassen-Template-Spezialisierung)
not_equal_to	Funktions-Objekt, das x != y implementiert (Klassen-Template)
not_equal_to<void> (C++14)	Funktions-Objekt, das x != y implementiert und Parameter- und Rückgabetypen ableitet (Klassen-Template-Spezialisierung)
greater	Funktions-Objekt, das x > y implementiert (Klassen-Template)
greater<void> (C++14)	Funktions-Objekt, das x > y implementiert und Parameter- und Rückgabetypen ableitet (Klassen-Template-Spezialisierung)
less	Funktions-Objekt, das x < y implementiert (Klassen-Template)
less<void> (C++14)	Funktions-Objekt, das x < y implementiert und Parameter- und Rückgabetypen ableitet (Klassen-Template-Spezialisierung)
greater_equal	Funktions-Objekt, das x >= y implementiert (Klassen-Template)
greater_equal<void> (C++14)	Funktions-Objekt, das x >= y implementiert und Parameter- und Rückgabetypen ableitet (Klassen-Template-Spezialisierung)
less_equal	Funktions-Objekt, das x <= y implementiert (Klassen-Template)
less_equal<void> (C++14)	Funktions-Objekt, das x <= y implementiert und Parameter- und Rückgabetypen ableitet (Klassen-Template-Spezialisierung)
Logische Operationen
logical_and	Funktions-Objekt, das x && y implementiert (Klassen-Template)
logical_and<void> (C++14)	Funktions-Objekt, das x && y implementiert und Parameter- und Rückgabetypen ableitet (Klassen-Template-Spezialisierung)
logical_or	Funktions-Objekt, das x || y implementiert (Klassen-Template)
logical_or<void> (C++14)	Funktions-Objekt, das x || y implementiert und Parameter- und Rückgabetypen ableitet (Klassen-Template-Spezialisierung)
logical_not	Funktions-Objekt, das !x implementiert (Klassen-Template)
logical_not<void> (C++14)	Funktions-Objekt, das !x implementiert und Parameter- und Rückgabetypen ableitet (Klassenvorlagenspezialisierung)
Bitweise Operationen
bit_and	Funktionsobjekt, das x & y implementiert (Klassenvorlage)
bit_and<void> (C++14)	Funktionsobjekt, das x & y implementiert, wobei Parameter- und Rückgabetypen abgeleitet werden (Klassenvorlagenspezialisierung)
bit_or	Funktionsobjekt, das x | y implementiert (Klassenvorlage)
bit_or<void> (C++14)	Funktionsobjekt, das x | y implementiert, wobei Parameter- und Rückgabetypen abgeleitet werden (Klassenvorlagenspezialisierung)
bit_xor	Funktionsobjekt, das x ^ y implementiert (Klassenvorlage)
bit_xor<void> (C++14)	Funktionsobjekt, das x ^ y implementiert, wobei Parameter- und Rückgabetypen abgeleitet werden (Klassenvorlagenspezialisierung)
bit_not (C++14)	Funktionsobjekt, das ~x implementiert (Klassenvorlage)
bit_not<void> (C++14)	Funktionsobjekt, das ~x implementiert, wobei Parameter- und Rückgabetypen abgeleitet werden (Klassenvorlagenspezialisierung)

Beschränkte Vergleichsfunktionsobjekte Die folgenden Vergleichsfunktionsobjekte sind beschränkt. Die Gleichheitsoperatoren (ranges::equal_to und ranges::not_equal_to) erfordern, dass die Typen der Argumente equality_comparable_with erfüllen. Die relationalen Operatoren (ranges::less, ranges::greater, ranges::less_equal und ranges::greater_equal) erfordern, dass die Typen der Argumente totally_ordered_with erfüllen. Der Drei-Wege-Vergleichsoperator (compare_three_way) erfordert, dass der Typ three_way_comparable_with modelliert. Alle diese Funktionsobjekte sind transparent. ranges::equal_to (C++20) Beschränktes Funktionsobjekt, das x == y implementiert (Klasse) ranges::not_equal_to (C++20) Beschränktes Funktionsobjekt, das x != y implementiert (Klasse) ranges::less (C++20) Beschränktes Funktionsobjekt, das x < y implementiert (Klasse) ranges::greater (C++20) Beschränktes Funktionsobjekt, das x > y implementiert (Klasse) ranges::less_equal (C++20) Beschränktes Funktionsobjekt, das x <= y implementiert (Klasse) ranges::greater_equal (C++20) Beschränktes Funktionsobjekt, das x >= y implementiert (Klasse) compare_three_way (C++20) beschränkte Funktionsobjekte, die x <=> y implementieren (Klasse)

(seit C++20)

Hilfselemente Die folgenden nur für die Exposition bestimmten Elemente werden für verschiedene Komponenten in der Standardbibliothek verwendet, sind aber nicht Teil der Schnittstelle der Standardbibliothek. template< class Fn, class... Args > concept /*callable*/ =     requires (Fn&& fn, Args&&... args) {         std::forward<Fn>(fn)(std::forward<Args>(args)...);     }; (1) (nur Exposition*) template< class Fn, class... Args > concept /*nothrow-callable*/ =     /*callable*/<Fn, Args...> &&     requires (Fn&& fn, Args&&... args) {         { std::forward<Fn>(fn)(std::forward<Args>(args)...) } noexcept;     }; (2) (nur Exposition*) template< class Fn, class... Args > using /*call-result-t*/ = decltype(std::declval<Fn>()(std::declval<Args>()...)); (3) (nur Exposition*) template< const auto& T > using /*decayed-typeof*/ = decltype(auto(T)); (4) (nur Exposition*)

(seit C++26)

Alte Binder und Adaptoren Einige Dienstprogramme, die eine frühe funktionale Unterstützung boten, sind veraltet und entfernt worden Basis unary_function (in C++11 veraltet)(in C++17 entfernt) Adaptor-kompatible Basisklasse für unäre Funktionen (Klassenvorlage) binary_function (in C++11 veraltet)(in C++17 entfernt) Adaptor-kompatible Basisklasse für binäre Funktionen (Klassenvorlage) Binder binder1stbinder2nd (in C++11 veraltet)(in C++17 entfernt) Funktionsobjekt, das eine binäre Funktion und eines ihrer Argumente speichert (Klassenvorlage) bind1stbind2nd (in C++11 veraltet)(in C++17 entfernt) bindet ein Argument an eine binäre Funktion (Funktionsvorlage) Funktionsadaptoren pointer_to_unary_function (in C++11 veraltet)(in C++17 entfernt) Adaptor-kompatibler Wrapper für einen Zeiger auf eine unäre Funktion (Klassenvorlage) pointer_to_binary_function (in C++11 veraltet)(in C++17 entfernt) Adaptor-kompatibler Wrapper für einen Zeiger auf eine binäre Funktion (Klassenvorlage) ptr_fun (in C++11 veraltet)(in C++17 entfernt) erstellt einen adaptor-kompatiblen Funktionsobjekt-Wrapper aus einem Funktionszeiger (Funktionsvorlage) mem_fun_tmem_fun1_tconst_mem_fun_tconst_mem_fun1_t (in C++11 veraltet)(in C++17 entfernt) Wrapper für einen Zeiger auf eine nulläre oder unäre Member-Funktion, aufrufbar mit einem Objektzeiger (Klassenvorlage) mem_fun (in C++11 veraltet)(in C++17 entfernt) erstellt einen Wrapper aus einem Zeiger auf eine Member-Funktion, aufrufbar mit einem Objektzeiger (Funktionsvorlage) mem_fun_ref_tmem_fun1_ref_tconst_mem_fun_ref_tconst_mem_fun1_ref_t (in C++11 veraltet)(in C++17 entfernt) Wrapper für einen Zeiger auf eine nulläre oder unäre Member-Funktion, aufrufbar mit einer Objekt-Referenz (Klassenvorlage) mem_fun_ref (in C++11 veraltet)(in C++17 entfernt) erstellt einen Wrapper aus einem Zeiger auf eine Member-Funktion, aufrufbar mit einer Objekt-Referenz (Funktionsvorlage) unary_negate (in C++17 veraltet)(in C++20 entfernt) Wrapper-Funktionsobjekt, das die Negation (Komplement) des von ihm gehaltenen unären Prädikats zurückgibt (Klassenvorlage) binary_negate (in C++17 veraltet)(in C++20 entfernt) Wrapper-Funktionsobjekt, das die Negation (Komplement) des von ihm gehaltenen binären Prädikats zurückgibt (Klassenvorlage) not1 (in C++17 veraltet)(in C++20 entfernt) konstruiert ein benutzerdefiniertes std::unary_negate-Objekt (Funktionsvorlage) not2 (in C++17 veraltet)(in C++20 entfernt) konstruiert ein benutzerdefiniertes std::binary_negate-Objekt (Funktionsvorlage)

(bis C++20)

Defect reports

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 185	C++98	die Verwendung von Funktionsobjekten verbesserte die Programmeffizienz	die Behauptung wurde entfernt
LWG 660	C++98	Funktionsobjekte für bitweise Operationen fehlen	hinzugefügt
LWG 2149	C++98	Funktionsobjekte, die ein oder zwei Argumente aufnahmen, mussten verschachtelte Typen zur Bezeichnung der Argument- und Ergebnistypen bereitstellen	nicht erforderlich.
LWG 2219	C++11	INVOKE behandelte std::reference_wrapper nicht korrekt	behandelt korrekt
LWG 2420	C++11	INVOKE<R> verwarf den Rückgabewert nicht, wenn R void war	verwirft den Rückgabewert in diesem Fall
LWG 2926 (P0604R0)	C++11	die Syntax der INVOKE-Operation mit einem Rückgabe- typ R war INVOKE(f, t1, t2, ..., tN, R)	geändert zu INVOKE<R>(f, t1, t2, ..., tN)
LWG 3655	C++11	INVOKE behandelte Unions nicht korrekt wegen der Auflösung von LWG-Problem 2219	behandelt korrekt