classes is_invocable, is_invocable_r, is_nothrow_invocable, is_nothrow_invocable_r

Ces modèles déterminent si un type peut être appelé avec les types d’arguments spécifiés. is_invocable_r et is_nothrow_invocable_r déterminez également si le résultat de l’appel est convertible en un type spécifique. is_nothrow_invocable et is_nothrow_invocable_r déterminez également si l’appel est connu pour ne pas lever d’exceptions. Ajouté dans C++17.

Syntaxe

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;

Paramètres

Callable
Type pouvant être appelé à interroger.

Args
Types d’arguments à interroger.

Convertible
Le type vers lequel le résultat de Callable doit être convertible.

Notes

Le is_invocable prédicat de type a la valeur true si le type appelant Callable peut être appelé à l’aide des arguments Args dans un contexte non évalué.

Le is_invocable_r prédicat de type a la valeur true si le type appelant Callable peut être appelé à l’aide des arguments Args dans un contexte non évalué pour produire un type de résultat convertible en convertible.

Le is_nothrow_invocable prédicat de type a la valeur true si le type callable peut être appelé à l’aide des arguments Args dans un contexte non évalué, et qu’un tel appel est connu pour ne pas lever d’exception.

Le is_nothrow_invocable_r prédicat de type a la valeur true si le type callable pouvant être appelé peut être appelé à l’aide des arguments Arg dans un contexte non évalué pour produire un type de résultat convertible en convertible, et qu’un tel appel est connu pour ne pas lever d’exception.

Chacun des types Convertible, Callable et les types du pack de paramètres Args doivent être un type complet, un tableau de limites inconnues ou éventuellement un cv qualifié void. Sinon, le comportement du prédicat n’est pas défini.

Exemple

// 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
}

Spécifications

Header :<type_traits>

Espace de noms : std

Voir aussi

<type_traits>
invoke