Namespaces
Variants

std:: is_invocable, std:: is_invocable_r, std:: is_nothrow_invocable, std:: is_nothrow_invocable_r

From cppreference.net
C++
Metaprogramming library
Type traits
Type categories
(C++11)
(C++11) ( DR* )
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
Type properties
(C++11)
(C++11)
(C++11)
(C++11)
(C++14)
(C++11)
(C++17)
(C++23)
(C++11) (deprecated in C++26)
(C++11)
(C++11)
(C++11) ( until C++20* )
(C++11) (deprecated in C++20)
(C++11)
(C++11)
(C++20)
(C++20)
(C++23)
(C++17)
Type trait constants
(C++11) (C++17) (C++11) (C++11)
Metafunctions
(C++17)
(C++17)
(C++17)
Supported operations
Relationships and property queries
(C++11)
(C++26)
(C++11)
(C++11)
(C++11)
is_invocable is_invocable_r is_nothrow_invocable is_nothrow_invocable_r
(C++17) (C++17) (C++17) (C++17)
Type modifications
Type transformations
(C++11) (deprecated in C++23)
(C++11) (deprecated in C++23)
(C++11)
(C++20)
(C++11) ( until C++20* ) (C++17)

Compile-time rational arithmetic
Compile-time integer sequences
(C++14)
Definiert im Header <type_traits>
template < class Fn, class ... ArgTypes >
struct is_invocable ;
(1) (seit C++17)
template < class R, class Fn, class ... ArgTypes >
struct is_invocable_r ;
(2) (seit C++17)
template < class Fn, class ... ArgTypes >
struct is_nothrow_invocable ;
(3) (seit C++17)
template < class R, class Fn, class ... ArgTypes >
struct is_nothrow_invocable_r ;
(4) (seit C++17)
1) Bestimmt, ob INVOKE ( std:: declval < Fn > ( ) , std:: declval < ArgTypes > ( ) ... ) wohlgeformt ist, wenn es als nicht ausgewerteter Operand behandelt wird.
2) Bestimmt, ob INVOKE<R> ( std:: declval < Fn > ( ) , std:: declval < ArgTypes > ( ) ... ) wohlgeformt ist, wenn es als nicht ausgewerteter Operand behandelt wird.
3) Bestimmt, ob INVOKE ( std:: declval < Fn > ( ) , std:: declval < ArgTypes > ( ) ... ) wohlgeformt ist, wenn es als nicht ausgewerteter Operand behandelt wird, und bekannt ist, dass es keine Ausnahmen auslöst.
4) Bestimmt, ob INVOKE<R> ( std:: declval < Fn > ( ) , std:: declval < ArgTypes > ( ) ... ) wohlgeformt ist, wenn es als nicht ausgewerteter Operand behandelt wird, und bekannt ist, dass es keine Ausnahmen auslöst.

Wenn Fn, R oder irgendein Typ im Parameterpaket ArgTypes kein vollständiger Typ, (möglicherweise cv-qualifiziert) void , oder ein Array unbekannter Größe ist, ist das Verhalten undefiniert.

Wenn eine Instanziierung einer Vorlage oben direkt oder indirekt von einem unvollständigen Typ abhängt und diese Instanziierung ein anderes Ergebnis liefern könnte, wenn dieser Typ hypothetisch vervollständigt würde, ist das Verhalten undefiniert.

Wenn das Programm Spezialisierungen für irgendwelche der auf dieser Seite beschriebenen Templates hinzufügt, ist das Verhalten undefiniert.

Inhaltsverzeichnis

Hilfsvariablen-Templates

Definiert im Header <type_traits>
template < class Fn, class ... ArgTypes >

inline constexpr bool is_invocable_v =

std :: is_invocable < Fn, ArgTypes... > :: value ;
(1) (seit C++17)
template < class R, class Fn, class ... ArgTypes >

inline constexpr bool is_invocable_r_v =

std :: is_invocable_r < R, Fn, ArgTypes... > :: value ;
(2) (seit C++17)
template < class Fn, class ... ArgTypes >

inline constexpr bool is_nothrow_invocable_v =

std :: is_nothrow_invocable < Fn, ArgTypes... > :: value ;
(3) (seit C++17)
template < class R, class Fn, class ... ArgTypes >

inline constexpr bool is_nothrow_invocable_r_v =

std :: is_nothrow_invocable_r < R, Fn, ArgTypes... > :: value ;
(4) (seit C++17)

Geerbt von std:: integral_constant

Member-Konstanten

value
[static]
true wenn (für Überladung (1) ) INVOKE ( std:: declval < Fn > ( ) , std:: declval < ArgTypes > ( ) ... ) wohlgeformt ist, wenn als nicht ausgewerteter Operand behandelt, false andernfalls
(öffentliche statische Member-Konstante)

Member-Funktionen

operator bool
konvertiert das Objekt zu bool , gibt value zurück
(öffentliche Member-Funktion)
operator()
(C++14)
gibt value zurück
(öffentliche Member-Funktion)

Member-Typen

Typ Definition
value_type bool
type std:: integral_constant < bool , value >

Hinweise

Feature-Test Makro Wert Std Feature
__cpp_lib_is_invocable 201703L (C++17) std::is_invocable , std::invoke_result

Beispiele

Diesen Code ausführen 
#include <type_traits>
auto func2(char) -> int (*)()
{
    return nullptr;
}
int main()
{
    static_assert(std::is_invocable_v<int()>);
    static_assert(not std::is_invocable_v<int(), int>);
    static_assert(std::is_invocable_r_v<int, int()>);
    static_assert(not std::is_invocable_r_v<int*, int()>);
    static_assert(std::is_invocable_r_v<void, void(int), int>);
    static_assert(not std::is_invocable_r_v<void, void(int), void>);
    static_assert(std::is_invocable_r_v<int(*)(), decltype(func2), char>);
    static_assert(not std::is_invocable_r_v<int(*)(), decltype(func2), void>);
}

Siehe auch

(C++17) (C++23)
ruft jedes Callable Objekt mit gegebenen Argumenten auf mit Möglichkeit zur Angabe des Rückgabetyps (seit C++23)
(Funktions-Template)
(C++11) (entfernt in C++20) (C++17)
leitet den Ergebnistyp des Aufrufs eines aufrufbaren Objekts mit einer Menge von Argumenten ab
(Klassen-Template)
(C++11)
erhält eine Referenz auf ein Objekt des Template-Typarguments zur Verwendung in einem nicht ausgewerteten Kontext
(Funktions-Template)
(C++20)
spezifiziert, dass ein aufrufbarer Typ mit einer gegebenen Menge von Argumenttypen aufgerufen werden kann
(Konzept)