std:: is_function

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)
result_of invoke_result (C++11) ( until C++20* ) (C++17)

conditional (C++11)
common_type (C++11)
common_reference (C++20)
underlying_type (C++11)
type_identity (C++20)
enable_if (C++11)
void_t (C++17)

Compile-time rational arithmetic

Compile-time integer sequences

integer_sequence

(C++14)

Definiert im Header `<type_traits>`
template < class T > struct is_function ;		(seit C++11)

std::is_function ist ein UnaryTypeTrait .

Prüft, ob T ein Funktionstyp ist. Typen wie std:: function , Lambdas, Klassen mit überladenem operator() und Zeiger auf Funktionen zählen nicht als Funktionstypen. Bietet die Member-Konstante value , die gleich true ist, wenn T ein Funktionstyp ist. Andernfalls ist value gleich false .

Wenn das Programm Spezialisierungen für std::is_function oder std::is_function_v hinzufügt, ist das Verhalten undefiniert.

Inhaltsverzeichnis

Template-Parameter

ein zu prüfender Typ

Hilfsvariablen-Template

template < class T > constexpr bool is_function_v = is_function < T > :: value ;		(seit C++17)

Geerbt von std:: integral_constant

Member-Konstanten

value

[static]

true wenn

ein Funktionstyp ist, false andernfalls
(öffentliche statische Member-Konstante)

Member-Funktionen

operator bool	konvertiert das Objekt zu bool , gibt value zurück (öffentliche Member-Funktion)
operator() (C++14)	gibt value zurück (öffentliche Member-Funktion)

Member-Typen

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

Hinweise

std::is_function kann auf viel einfachere Weise implementiert werden. Implementierungen ähnlich der folgenden werden von neueren Versionen von libc++ , libstdc++ und MS STL verwendet:

template<class T>
struct is_function : std::integral_constant<
    bool,
    !std::is_const<const T>::value && !std::is_reference<T>::value
> {};

Die unten gezeigte Implementierung dient pädagogischen Zwecken, da sie die vielfältigen Arten von Funktionstypen veranschaulicht.

Mögliche Implementierung

// primary template
template<class>
struct is_function : std::false_type {};
// Spezialisierung für reguläre Funktionen
template<class Ret, class... Args>
struct is_function<Ret(Args...)> : std::true_type {};
// Spezialisierung für variadische Funktionen wie std::printf
template<class Ret, class... Args>
struct is_function<Ret(Args......)> : std::true_type {};
// Spezialisierung für Funktionstypen mit CV-Qualifizierern
template<class Ret, class... Args>
struct is_function<Ret(Args...) const> : std::true_type {};
template<class Ret, class... Args>
struct is_function<Ret(Args...) volatile> : std::true_type {};
template<class Ret, class... Args>
struct is_function<Ret(Args...) const volatile> : std::true_type {};
template<class Ret, class... Args>
struct is_function<Ret(Args......) const> : std::true_type {};
template<class Ret, class... Args>
struct is_function<Ret(Args......) volatile> : std::true_type {};
template<class Ret, class... Args>
struct is_function<Ret(Args......) const volatile> : std::true_type {};
// Spezialisierung für Funktionstypen mit Ref-Qualifiers
template<class Ret, class... Args>
struct is_function<Ret(Args...) &> : std::true_type {};
template<class Ret, class... Args>
struct is_function<Ret(Args...) const &> : std::true_type {};
template<class Ret, class... Args>
struct is_function<Ret(Args...) volatile &> : std::true_type {};
template<class Ret, class... Args>
struct is_function<Ret(Args...) const volatile &> : std::true_type {};
template<class Ret, class... Args>
struct is_function<Ret(Args......) &> : std::true_type {};
template<class Ret, class... Args>
struct is_function<Ret(Args......) const &> : std::true_type {};
template<class Ret, class... Args>
struct is_function<Ret(Args......) volatile &> : std::true_type {};
template<class Ret, class... Args>
struct is_function<Ret(Args......) const volatile &> : std::true_type {};
template<class Ret, class... Args>
struct is_function<Ret(Args...) &&> : std::true_type {};
template<class Ret, class... Args>
struct is_function<Ret(Args...) const &&> : std::true_type {};
template<class Ret, class... Args>
struct is_function<Ret(Args...) volatile &&> : std::true_type {};
template<class Ret, class... Args>
struct is_function<Ret(Args...) const volatile &&> : std::true_type {};
template<class Ret, class... Args>
struct is_function<Ret(Args......) &&> : std::true_type {};
template<class Ret, class... Args>
struct is_function<Ret(Args......) const &&> : std::true_type {};
template<class Ret, class... Args>
struct is_function<Ret(Args......) volatile &&> : std::true_type {};
template<class Ret, class... Args>
struct is_function<Ret(Args......) const volatile &&> : std::true_type {};
// Spezialisierungen für noexcept-Versionen aller oben genannten (C++17 und später)
template<class Ret, class... Args>
struct is_function<Ret(Args...) noexcept> : std::true_type {};
template<class Ret, class... Args>
struct is_function<Ret(Args......) noexcept> : std::true_type {};
template<class Ret, class... Args>
struct is_function<Ret(Args...) const noexcept> : std::true_type {};
template<class Ret, class... Args>
struct is_function<Ret(Args...) volatile noexcept> : std::true_type {};
template<class Ret, class... Args>
struct is_function<Ret(Args...) const volatile noexcept> : std::true_type {};
template<class Ret, class... Args>
struct is_function<Ret(Args......) const noexcept> : std::true_type {};
template<class Ret, class... Args>
struct is_function<Ret(Args......) volatile noexcept> : std::true_type {};
template<class Ret, class... Args>
struct is_function<Ret(Args......) const volatile noexcept> : std::true_type {};
template<class Ret, class... Args>
struct is_function<Ret(Args...) & noexcept> : std::true_type {};
template<class Ret, class... Args>
struct is_function<Ret(Args...) const & noexcept> : std::true_type {};
template<class Ret, class... Args>
struct is_function<Ret(Args...) volatile & noexcept> : std::true_type {};
template<class Ret, class... Args>
struct is_function<Ret(Args...) const volatile & noexcept> : std::true_type {};
template<class Ret, class... Args>
struct is_function<Ret(Args......) & noexcept> : std::true_type {};
template<class Ret, class... Args>
struct is_function<Ret(Args......) const & noexcept> : std::true_type {};
template<class Ret, class... Args>
struct is_function<Ret(Args......) volatile & noexcept> : std::true_type {};
template<class Ret, class... Args>
struct is_function<Ret(Args......) const volatile & noexcept> : std::true_type {};
template<class Ret, class... Args>
struct is_function<Ret(Args...) && noexcept> : std::true_type {};
template<class Ret, class... Args>
struct is_function<Ret(Args...) const && noexcept> : std::true_type {};
template<class Ret, class... Args>
struct is_function<Ret(Args...) volatile && noexcept> : std::true_type {};
template<class Ret, class... Args>
struct is_function<Ret(Args...) const volatile && noexcept> : std::true_type {};
template<class Ret, class... Args>
struct is_function<Ret(Args......) && noexcept> : std::true_type {};
template<class Ret, class... Args>
struct is_function<Ret(Args......) const && noexcept> : std::true_type {};
template<class Ret, class... Args>
struct is_function<Ret(Args......) volatile && noexcept> : std::true_type {};
template<class Ret, class... Args>
struct is_function<Ret(Args......) const volatile && noexcept> : std::true_type {};

Beispiel

Diesen Code ausführen

#include <functional>
#include <type_traits>
int f();
static_assert(std::is_function_v<decltype(f)>);
static_assert(std::is_function_v<int(int)>);
static_assert(!std::is_function_v<int>);
static_assert(!std::is_function_v<decltype([]{})>);
static_assert(!std::is_function_v<std::function<void()>>);
struct O { void operator()() {} };
static_assert(std::is_function_v<O()>);
struct A
{
    static int foo();
    int fun() const&;
};
static_assert(!std::is_function_v<A>);
static_assert(std::is_function_v<decltype(A::foo)>);
static_assert(!std::is_function_v<decltype(&A::fun)>);
template<typename>
struct PM_traits {};
template<class T, class U>
struct PM_traits<U T::*> { using member_type = U; };
int main()
{
    using T = PM_traits<decltype(&A::fun)>::member_type; // T ist int() const&
    static_assert(std::is_function_v<T>);
}

Siehe auch

is_invocable is_invocable_r is_nothrow_invocable is_nothrow_invocable_r (C++17)	prüft, ob ein Typ mit den gegebenen Argumenttypen aufgerufen werden kann (als ob durch std::invoke ) (Klassentemplate)
is_object (C++11)	prüft, ob ein Typ ein Objekttyp ist (Klassentemplate)
is_class (C++11)	prüft, ob ein Typ ein Nicht-Union-Klassentyp ist (Klassentemplate)

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)
Diagnostics library
Memory management library
Metaprogramming library (C++11)
General utilities library
Containers library
Iterators library
Ranges library (C++20)
Algorithms library
Strings library
Text processing library
Numerics library
Date and time library
Input/output library
Filesystem library (C++17)
Concurrency support library (C++11)
Execution control library (C++26)
Technical specifications
Symbols index
External libraries

cppreference.net

Namespaces

Variants