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

is_constructible is_trivially_constructible is_nothrow_constructible (C++11) (C++11) (C++11)
is_default_constructible is_trivially_default_constructible is_nothrow_default_constructible (C++11) (C++11) (C++11)
is_copy_constructible is_trivially_copy_constructible is_nothrow_copy_constructible (C++11) (C++11) (C++11)
is_move_constructible is_trivially_move_constructible is_nothrow_move_constructible (C++11) (C++11) (C++11)
is_assignable is_trivially_assignable is_nothrow_assignable (C++11) (C++11) (C++11)

is_copy_assignable is_trivially_copy_assignable is_nothrow_copy_assignable (C++11) (C++11) (C++11)
is_move_assignable is_trivially_move_assignable is_nothrow_move_assignable (C++11) (C++11) (C++11)
is_destructible is_trivially_destructible is_nothrow_destructible (C++11) (C++11) (C++11)
has_virtual_destructor (C++11)
is_swappable_with is_swappable is_nothrow_swappable_with is_nothrow_swappable (C++17) (C++17) (C++17) (C++17)

Relationships and property queries

is_same (C++11)
is_convertible is_nothrow_convertible (C++11) (C++20)
is_layout_compatible (C++20)
is_pointer_interconvertible_base_of (C++20)
is_pointer_interconvertible_with_class (C++20)
is_corresponding_member (C++20)
reference_constructs_from_temporary (C++23)
reference_converts_from_temporary (C++23)

is_base_of (C++11)
is_virtual_base_of (C++26)
alignment_of (C++11)
rank (C++11)
extent (C++11)
is_invocable is_invocable_r is_nothrow_invocable is_nothrow_invocable_r (C++17) (C++17) (C++17) (C++17)

Type modifications

remove_cv remove_const remove_volatile (C++11) (C++11) (C++11)
add_cv add_const add_volatile (C++11) (C++11) (C++11)
make_signed (C++11)
make_unsigned (C++11)

remove_reference (C++11)
add_lvalue_reference add_rvalue_reference (C++11) (C++11)
remove_pointer (C++11)
add_pointer (C++11)
remove_extent (C++11)
remove_all_extents (C++11)

Type transformations

aligned_storage (C++11) (deprecated in C++23)
aligned_union (C++11) (deprecated in C++23)
decay (C++11)
remove_cvref (C++20)
enable_if (C++11)
void_t (C++17)

conditional (C++11)
common_type (C++11)
common_reference (C++20)
underlying_type (C++11)
result_of invoke_result (C++11) ( until C++20* ) (C++17)
type_identity (C++20)

Compile-time rational arithmetic

Compile-time integer sequences

integer_sequence

(C++14)

Defined in header `<type_traits>`
template < class Fn, class ... ArgTypes > struct is_invocable ;	(1)	(since C++17)
template < class R, class Fn, class ... ArgTypes > struct is_invocable_r ;	(2)	(since C++17)
template < class Fn, class ... ArgTypes > struct is_nothrow_invocable ;	(3)	(since C++17)
template < class R, class Fn, class ... ArgTypes > struct is_nothrow_invocable_r ;	(4)	(since C++17)

1) Determines whether INVOKE ( std:: declval < Fn > ( ) , std:: declval < ArgTypes > ( ) ... ) is well formed when treated as an unevaluated operand.

2) Determines whether INVOKE<R> ( std:: declval < Fn > ( ) , std:: declval < ArgTypes > ( ) ... ) is well formed when treated as an unevaluated operand.

3) Determines whether INVOKE ( std:: declval < Fn > ( ) , std:: declval < ArgTypes > ( ) ... ) is well formed when treated as an unevaluated operand, and is known not to throw any exceptions.

4) Determines whether INVOKE<R> ( std:: declval < Fn > ( ) , std:: declval < ArgTypes > ( ) ... ) is well formed when treated as an unevaluated operand, and is known not to throw any exceptions.

If Fn, R or any type in the parameter pack ArgTypes is not a complete type, (possibly cv-qualified) void , or an array of unknown bound, the behavior is undefined.

If an instantiation of a template above depends, directly or indirectly, on an incomplete type, and that instantiation could yield a different result if that type were hypothetically completed, the behavior is undefined.

If the program adds specializations for any of the templates described on this page, the behavior is undefined.

Helper variable templates

Defined in header `<type_traits>`
template < class Fn, class ... ArgTypes > inline constexpr bool is_invocable_v = std :: is_invocable < Fn, ArgTypes... > :: value ;	(1)	(since 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)	(since C++17)
template < class Fn, class ... ArgTypes > inline constexpr bool is_nothrow_invocable_v = std :: is_nothrow_invocable < Fn, ArgTypes... > :: value ;	(3)	(since 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)	(since C++17)

Inherited from std:: integral_constant

Member constants

value

[static]

true if (for overload (1) ) INVOKE ( std:: declval < Fn > ( ) , std:: declval < ArgTypes > ( ) ... ) is well formed when treated as an unevaluated operand, false otherwise
(public static member constant)

Member functions

operator bool	converts the object to bool , returns value (public member function)
operator() (C++14)	returns value (public member function)

Member types

Type	Definition
`value_type`	bool
`type`	std:: integral_constant < bool , value >

Notes

Feature-test macro	Value	Std	Feature
`__cpp_lib_is_invocable`	201703L	(C++17)	`std::is_invocable` , std::invoke_result

Examples

Run this code

#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>);
}

Compiler support
Freestanding and hosted
Language
Standard library
Standard library headers
Named requirements
Feature test macros (C++20)
Language support library
Concepts library (C++20)
Metaprogramming library (C++11)
Diagnostics library
General utilities library
Strings library
Containers library
Iterators library
Ranges library (C++20)
Algorithms library
Numerics library
Localizations library
Input/output library
Filesystem library (C++17)
Regular expressions library (C++11)
Concurrency support library (C++11)
Execution support library (C++26)
Technical specifications
Symbols index
External libraries

invoke invoke_r (C++17) (C++23)	invokes any Callable object with given arguments and possibility to specify return type (since C++23) (function template)
result_of invoke_result (C++11) (removed in C++20) (C++17)	deduces the result type of invoking a callable object with a set of arguments (class template)
declval (C++11)	obtains a reference to an object of the template type argument for use in an unevaluated context (function template)
invocable regular_invocable (C++20)	specifies that a callable type can be invoked with a given set of argument types (concept)