Namespaces
Variants

    std::meta::is_enumerable_type

    Aus de.cppreference.net
    < cpp | meta
     
    C++
     
    Metaprogrammierungsbibliothek
     
    Reflexionsbibliothek
     
    Reflexionstypen und -abfragen
    Reflexionsabfragen
        
        
    Layout-Abfragen der Reflexion
    Typeigenschaften
    Abfragen zu Typeigenschaften
     
    Definiert in Header <meta> 
    consteval bool is_enumerable_type( std::meta::info r );
    		(seit C++26)

    Bestimmt, ob r einen vollständigen Klassentyp oder einen Enum-Typ darstellt, dessen Liste der Enumeratoren vollständig definiert ist, oder einen Typalias davon.

    Formal ist ein Typ T von einem Punkt P aus aufzählbar (enumerable), wenn:

    • T ein zum Punkt P vollständiger Klassentyp ist oder
    • Tein Aufzählungstyp ist, der durch eine Deklaration D definiert ist, sodass D von P aus erreichbar ist und P nicht innerhalb eines enum-Spezifizierers von D auftritt.

    Parameter

    r - ein Reflexionswert

    Rückgabewert

    true genau dann, wenn std::meta::dealias(r) einen Typ darstellt, der von einem Punkt im Auswertungskontext aus aufzählbar ist, andernfalls false

    Hinweise

    Standard-Reflexionsfunktionen erfordern, dass ein Typ aufzählbar ist, um seine Liste von Basisklassen, Membern oder Enumeratoren zu erhalten.

    Beispiel

    Diesen Code ausführen
    #include <meta>

struct A; // incomplete type
static_assert(std::meta::is_enumerable_type(^^A) == false);

struct B {}; // complete type
static_assert(std::meta::is_enumerable_type(^^B) == true);

template <typename>
struct C; // incomplete class template
static_assert(std::meta::is_enumerable_type(^^C<long>) == false);

template <>
struct C<int> {}; // complete explicit template specialization
static_assert(std::meta::is_enumerable_type(^^C<int>) == true);

template <>
struct C<long>; // incomplete explicit template specialization
static_assert(std::meta::is_enumerable_type(^^C<long>) == false);

enum class E;
static_assert(std::meta::is_enumerable_type(^^E) == false);

enum class E { e };
static_assert(std::meta::is_enumerable_type(^^E) == true);
static_assert(std::meta::is_enumerable_type(^^E::e) == false);

union U;
static_assert(std::meta::is_enumerable_type(^^U) == false);

union U { int i; short j; };
static_assert(std::meta::is_enumerable_type(^^U) == true);

int main() {}

    Siehe auch

    (C++26)
    		 prüft, ob eine Reflexion einen vollständigen Typ darstellt
    (Funktion)