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)
Definido en el encabezado <type_traits>
template < class Fn, class ... ArgTypes >
struct is_invocable ;
(1) (desde C++17)
template < class R, class Fn, class ... ArgTypes >
struct is_invocable_r ;
(2) (desde C++17)
template < class Fn, class ... ArgTypes >
struct is_nothrow_invocable ;
(3) (desde C++17)
template < class R, class Fn, class ... ArgTypes >
struct is_nothrow_invocable_r ;
(4) (desde C++17)
1) Determina si INVOKE ( std:: declval < Fn > ( ) , std:: declval < ArgTypes > ( ) ... ) está bien formado cuando se trata como un operando no evaluado.
2) Determina si INVOKE<R> ( std:: declval < Fn > ( ) , std:: declval < ArgTypes > ( ) ... ) está bien formado cuando se trata como un operando no evaluado.
3) Determina si INVOKE ( std:: declval < Fn > ( ) , std:: declval < ArgTypes > ( ) ... ) está bien formado cuando se trata como un operando no evaluado, y se sabe que no lanza ninguna excepción.
4) Determina si INVOKE<R> ( std:: declval < Fn > ( ) , std:: declval < ArgTypes > ( ) ... ) está bien formado cuando se trata como un operando no evaluado, y se sabe que no lanza ninguna excepción.

Si Fn, R o cualquier tipo en el paquete de parámetros ArgTypes no es un tipo completo, (posiblemente calificado cv) void , o un array de límite desconocido, el comportamiento es indefinido.

Si una instanciación de una plantilla anterior depende, directa o indirectamente, de un tipo incompleto, y esa instanciación podría producir un resultado diferente si ese tipo se completara hipotéticamente, el comportamiento no está definido.

Si el programa añade especializaciones para cualquiera de las plantillas descritas en esta página, el comportamiento no está definido.

Contenidos

Plantillas de variables auxiliares

Definido en el encabezado <type_traits>
template < class Fn, class ... ArgTypes >

inline constexpr bool is_invocable_v =

std :: is_invocable < Fn, ArgTypes... > :: value ;
(1) (desde 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) (desde C++17)
template < class Fn, class ... ArgTypes >

inline constexpr bool is_nothrow_invocable_v =

std :: is_nothrow_invocable < Fn, ArgTypes... > :: value ;
(3) (desde 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) (desde C++17)

Heredado de std:: integral_constant

Constantes miembro

value
[static]
true si (para la sobrecarga (1) ) INVOKE ( std:: declval < Fn > ( ) , std:: declval < ArgTypes > ( ) ... ) está bien formado cuando se trata como un operando no evaluado, false en caso contrario
(constante miembro pública estática)

Funciones miembro

operator bool
convierte el objeto a bool , devuelve value
(función miembro pública)
operator()
(C++14)
devuelve value
(función miembro pública)

Tipos miembro

Tipo Definición
value_type bool
type std:: integral_constant < bool , value >

Notas

Macro de prueba de características Valor Std Característica
__cpp_lib_is_invocable 201703L (C++17) std::is_invocable , std::invoke_result

Ejemplos

Ejecutar este código 
#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>);
}

Véase también

(C++17) (C++23)
invoca cualquier Callable object con los argumentos dados y posibilidad de especificar el tipo de retorno (since C++23)
(plantilla de función)
(C++11) (removed in C++20) (C++17)
deduce el tipo de resultado de invocar un objeto llamable con un conjunto de argumentos
(plantilla de clase)
(C++11)
obtiene una referencia a un objeto del tipo de argumento de plantilla para usar en un contexto no evaluado
(plantilla de función)
(C++20)
especifica que un tipo llamable puede ser invocado con un conjunto dado de tipos de argumentos
(concepto)