is_invocable-, is_invocable_r-, is_nothrow_invocable-, is_nothrow_invocable_r-Klassen

Diese Vorlagen bestimmen, ob ein Typ mit den angegebenen Argumenttypen aufgerufen werden kann. is_invocable_r und is_nothrow_invocable_r ermitteln Sie auch, ob das Ergebnis des Aufrufs in einen bestimmten Typ umsetzbar ist. is_nothrow_invocable und is_nothrow_invocable_r ermitteln Sie auch, ob der Aufruf keine Ausnahmen auslösen kann. In C++17 hinzugefügt.

Syntax

template <class Callable, class... Args>
struct is_invocable;

template <class Convertible, class Callable, class... Args>
struct is_invocable_r;

template <class Callable, class... Args>
struct is_nothrow_invocable;

template <class Convertible, class Callable, class... Args>
struct is_nothrow_invocable_r;

// Helper templates
template <class Callable, class... Args>
inline constexpr bool is_invocable_v =
    std::is_invocable<Callable, Args...>::value;

template <class Convertible, class Callable, class... Args>
inline constexpr bool is_invocable_r_v =
    std::is_invocable_r<Convertible, Callable, Args...>::value;

template <class Callable, class... Args>
inline constexpr bool is_nothrow_invocable_v =
    std::is_nothrow_invocable<Callable, Args...>::value;

template <class Convertible, class Callable, class... Args>
inline constexpr bool is_nothrow_invocable_r_v =
    std::is_nothrow_invocable_r<Convertible, Callable, Args...>::value;

Parameter

Aufrufbaren
Der abzufragende, aufgerufene Typ.

args
Die zu abfragenden Argumenttypen.

Cabrio
Der Typ, in den das Ergebnis der Anruffähigen zu konvertierbar sein muss.

Hinweise

Das is_invocable Typprädikat enthält "true", wenn der aufrufbare Typ "Aufrufbar " mithilfe der Argumente "Args" in einem nicht ausgewerteten Kontext aufgerufen werden kann.

Das is_invocable_r Typprädikat enthält "true", wenn der aufrufbare Typ "Aufrufbar " mit den Argumenten "Args" in einem nicht ausgewerteten Kontext aufgerufen werden kann, um ein Ergebnistypkonvertierbar in "Convertible" zu erzeugen.

Das is_nothrow_invocable Typprädikat enthält "true", wenn der aufrufbare Typ "Aufrufbar " mithilfe der Argumente "Args" in einem nicht ausgewerteten Kontext aufgerufen werden kann und dass ein solcher Aufruf bekannt ist, dass keine Ausnahme ausgelöst wird.

Das is_nothrow_invocable_r Typprädikat enthält "true", wenn der aufrufbare Typ "Aufrufbar " mit den Argumenten "Args" in einem nicht ausgewerteten Kontext aufgerufen werden kann, um eine Ergebnistypkonvertierbar in "Cabrio" zu erzeugen, und dass ein solcher Aufruf bekannt ist, dass keine Ausnahme ausgelöst wird.

Jeder der Typen "Convertible", "Callable" und die Typen in den Parameter pack Args müssen ein vollständiger Typ, ein Array unbekannter Gebundenes oder möglicherweise cv-qualifizierter voidTyp sein. Andernfalls ist das Verhalten des Prädikats nicht definiert.

Beispiel

// std__type_traits__is_invocable.cpp
// compile using: cl /EHsc /std:c++17 std__type_traits__is_invocable.cpp
#include <type_traits>

auto test1(int) noexcept -> int (*)()
{
    return nullptr;
}

auto test2(int) -> int (*)()
{
    return nullptr;
}

int main()
{
    static_assert( std::is_invocable<decltype(test1), short>::value );

    static_assert( std::is_invocable_r<int(*)(), decltype(test1), int>::value );
    static_assert( std::is_invocable_r<long(*)(), decltype(test1), int>::value ); // fails

    static_assert( std::is_nothrow_invocable<decltype(test1), int>::value );
    static_assert( std::is_nothrow_invocable<decltype(test2), int>::value ); // fails

    static_assert( std::is_nothrow_invocable_r<int(*)(), decltype(test1), int>::value );
    static_assert( std::is_nothrow_invocable_r<int(*)(), decltype(test2), int>::value ); // fails
}

Anforderungen

Header:<type_traits>

Namespace: std

Siehe auch

<type_traits>
invoke