is_invocable, is_invocable_r, is_nothrow_invocable, is_nothrow_invocable_r classes

Esses modelos determinam se um tipo pode ser invocado com os tipos de argumento especificados. is_invocable_r e is_nothrow_invocable_r também determinam se o resultado da invocação é conversível para um tipo específico. is_nothrow_invocable e is_nothrow_invocable_r também determinam se a invocação é conhecida por não gerar exceções. Adicionado em C++17.

Sintaxe

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;

Parâmetros

Callable
O tipo callable para consulta.

Args
Os tipos de argumento a serem consultados.

Conversível
O tipo para o qual o resultado de Callable deve ser conversível.

Comentários

O predicado de tipo is_invocable se manterá verdadeiro se o tipo resgatável Callable puder ser invocado usando os argumentos Args em um contexto não avaliado.

O predicado de tipo is_invocable_r se manterá verdadeiro se o tipo resgatávelCallable puder ser invocado usando os argumentos Args em um contexto não avaliado para produzir um tipo de resultado conversível para Convertible.

O predicado de tipo is_nothrow_invocable se manterá verdadeiro se o tipo resgatável Callable puder ser invocado usando os argumentos Args em um contexto não avaliado e se essa chamada for conhecida por não gerar uma exceção.

O predicado de tipo is_nothrow_invocable_r se manterá verdadeiro se o tipo resgatável Callable puder ser invocado usando os argumentos Args em um contexto não avaliado para produzir um tipo de resultado conversível para Convertible e se essa chamada for conhecida por não gerar uma exceção.

Cada um dos tipos Convertible, Callable e os tipos no pacote de parâmetros Args devem ser um tipo completo, uma matriz de limite desconhecido ou um void possivelmente qualificado por cv. Caso contrário, o comportamento do predicado será indefinido.

Exemplo

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

Requisitos

Cabeçalho:<type_traits>

Namespace: std

Confira também

<type_traits>
invoke