Experimental library header <experimental/reflect>

From cppreference.net

<experimental/execution>

Filesystem TS

<experimental/filesystem>

Parallelism TS (v1, v2)

`experimental/algorithm`
`experimental/execution_policy`
`experimental/exception_list`

`experimental/numeric`
`<experimental/simd>`
`experimental/task_block`

Library Fundamentals TS (v1, v2, v3)

`experimental/algorithm`
`<experimental/any>`
`experimental/array`
`experimental/chrono`
`experimental/deque`
`experimental/forward_list`
`<experimental/functional>`
`experimental/future`
`experimental/iterator`
`experimental/list`
`experimental/map`
`experimental/memory`
`<experimental/memory_resource>`
`experimental/numeric`
`<experimental/optional>`
`experimental/propagate_const`

`experimental/random`
`experimental/ratio`
`experimental/regex`
`experimental/scope`
`experimental/set`
`experimental/source_location`
`experimental/string`
`<experimental/string_view>`
`experimental/system_error`
`experimental/tuple`
`experimental/type_traits`
`experimental/unordered_map`
`experimental/unordered_set`
`experimental/utility`
`experimental/vector`

Concurrency TS

`experimental/atomic`
`experimental/barrier`

`experimental/future`
`experimental/latch`

Ranges TS

`<experimental/ranges/algorithm>`
`<experimental/ranges/concepts>`
`<experimental/ranges/functional>`
`<experimental/ranges/iterator>`

`<experimental/ranges/random>`
`<experimental/ranges/tuple>`
`<experimental/ranges/type_traits>`
`<experimental/ranges/utility>`

Coroutines TS


               experimental/coroutine

Networking TS

`experimental/buffer`
`experimental/executor`
`experimental/internet`
`experimental/io_context`

`<experimental/net>`
`experimental/netfwd`
`experimental/socket`
`experimental/timer`

Reflection TS

<experimental/reflect>

Dieser Header ist Teil des Reflection TS .

**Anmerkungen zur Übersetzung:** - HTML-Tags und Attribute wurden unverändert beibehalten - C++-spezifische Begriffe (wie ObjectSequence, Callable, Lambda etc.) wurden nicht übersetzt - Technische Begriffe wurden konsistent und professionell übersetzt - Die ursprüngliche Formatierung und Struktur wurde vollständig erhalten - "Contents" wurde zu "Inhaltsverzeichnis" übersetzt - "Concepts" wurde zu "Konzepte" übersetzt - "Classes" wurde zu "Klassen" übersetzt - "Synopsis" wurde zu "Übersicht" übersetzt

Definiert in namespace


           std::experimental::reflect

Definiert im Inline-Namespace


           std::experimental::reflect::v1

Inhaltsverzeichnis

Konzepte

Object

(reflection TS)

spezifiziert, dass ein Typ ein Metaobjekt-Typ ist
(Konzept)

ObjectSequence

(reflection TS)

spezifiziert, dass ein Metaobjekt-Typ ein Metaobjekt-Sequenz-Typ ist
(Konzept)

TemplateParameterScope

(reflection TS)

gibt an, dass ein Metaobjekttyp einen Template-Parameterbereich reflektiert
(Konzept)

Named

(reflection TS)

spezifiziert, dass ein Metaobjekttyp eine Entität oder einen Alias mit einem zugehörigen (möglicherweise leeren) Namen reflektiert
(Konzept)

Alias

(reflection TS)

gibt an, dass ein Metaobjekttyp einen Typalias, Namensraumalias oder einen durch eine using-Deklaration eingeführten Alias widerspiegelt
(Konzept)

RecordMember

(reflection TS)

spezifiziert, dass ein Metaobjekt-Typ eine member-declaration einer Klasse reflektiert
(Konzept)

Enumerator

(reflection TS)

spezifiziert, dass ein Metaobjekttyp einen Enumerator reflektiert
(Konzept)

Variable

(reflection TS)

gibt an, dass ein Metaobjekttyp eine Variable oder ein Datenelement reflektiert
(Konzept)

ScopeMember

(reflection TS)

spezifiziert, dass ein Metaobjekt-Typ


          RecordMember


          Enumerator

oder


          Variable

erfüllt, oder einen anderen Namespace als den globalen Namespace reflektiert
(Konzept)

Typed

(reflection TS)

gibt an, dass ein Metaobjekttyp eine Entität mit einem Typ widerspiegelt
(Konzept)

Namespace

(reflection TS)

gibt an, dass ein Metaobjekttyp einen Namespace reflektiert
(Konzept)

GlobalScope

(reflection TS)

gibt an, dass ein Metaobjekttyp den globalen Namensraum reflektiert
(Konzept)

Class

(reflection TS)

gibt an, dass ein Metaobjekttyp einen Nicht-Union-Klassentyp reflektiert
(Konzept)

Enum

(reflection TS)

gibt an, dass ein Metaobjekttyp einen Aufzählungstyp reflektiert
(Konzept)

Record

(reflection TS)

gibt an, dass ein Metaobjekttyp einen Klassentyp reflektiert
(Konzept)

Scope

(reflection TS)

gibt an, dass ein Metaobjekttyp einen Namespace, eine Klasse, eine Enumeration, eine Funktion, einen Closure-Typ oder einen Template-Parameter-Bereich reflektiert
(Konzept)

Type

(reflection TS)

gibt an, dass ein Metaobjekttyp einen Typ reflektiert
(Konzept)

Constant

(reflection TS)

gibt an, dass ein Metaobjekttyp einen Enumerator oder eine constexpr-Variable reflektiert
(Konzept)

Base

(reflection TS)

spezifiziert, dass ein Metaobjekttyp eine direkte Basisklasse widerspiegelt, die von


          get_base_classes

erhalten wurde
(Konzept)

FunctionParameter

(reflection TS)

gibt an, dass ein Metaobjekttyp einen Funktionsparameter reflektiert
(Konzept)

Callable

(reflection TS)

gibt an, dass ein Metaobjekttyp eine Funktion reflektiert (einschließlich Konstruktoren und Destruktoren)
(Konzept)

Expression

(reflection TS)

gibt an, dass ein Metaobjekttyp einen Ausdruck reflektiert
(Konzept)

ParenthesizedExpression

(reflection TS)

gibt an, dass ein Metaobjekttyp einen geklammerten Ausdruck reflektiert
(Konzept)

FunctionCallExpression

(reflection TS)

gibt an, dass ein Metaobjekttyp einen function-call-expression reflektiert
(Konzept)

FunctionalTypeConversion

(reflection TS)

gibt an, dass ein Metaobjekttyp einen functional-type-conv-expression reflektiert
(Konzept)

Function

(reflection TS)

gibt an, dass ein Metaobjekttyp eine Funktion reflektiert (ausgenommen Konstruktoren und Destruktoren)
(Konzept)

MemberFunction

(reflection TS)

gibt an, dass ein Metaobjekttyp eine Memberfunktion widerspiegelt (ausgenommen Konstruktoren und Destruktoren)
(Konzept)

SpecialMemberFunction

(reflection TS)

gibt an, dass ein Metaobjekttyp eine spezielle Memberfunktion reflektiert
(Konzept)

Constructor

(reflection TS)

gibt an, dass ein Metaobjekttyp einen Konstruktor reflektiert
(Konzept)

Destructor

(reflection TS)

gibt an, dass ein Metaobjekttyp einen Destruktor reflektiert
(Konzept)

Operator

(reflection TS)

gibt an, dass ein Metaobjekttyp eine Operatorfunktion oder eine Konvertierungsfunktion reflektiert
(Konzept)

ConversionOperator

(reflection TS)

gibt an, dass ein Metaobjekttyp eine Konvertierungsfunktion widerspiegelt
(Konzept)

Lambda

(reflection TS)

gibt an, dass ein Metaobjekttyp den Closure-Typ eines nicht-generischen Lambda reflektiert
(Konzept)

LambdaCapture

(reflection TS)

gibt an, dass ein Metaobjekttyp eine Lambda-Capture reflektiert
(Konzept)

Klassen

`Object` Operationen

reflects_same

(reflection TS)

prüft, ob zwei Metaobjekttypen dieselbe Entität oder denselben Alias reflektieren
(Klassentemplate)

get_source_line

(reflection TS)

ermittelt die vermutliche Zeilennummer der Deklaration der reflektierten Entität oder des Alias
(Klassentemplate)

get_source_column

(reflection TS)

Ermittelt die implementierungsdefinierte Spaltennummer der Deklaration der reflektierten Entität oder des Alias
(Klassentemplate)

get_source_file_name

(reflection TS)

ermittelt den vermuteten Dateinamen der Deklaration der reflektierten Entität oder des Alias
(Klassentemplate)

`ObjectSequence` Operationen

get_size

(reflection TS)

ermittelt die Größe einer Metaobjektsequenz
(Klassentemplate)

get_element

(reflection TS)

erhält den Metaobjekt-Typ mit angegebenem Index in einer Sequenz
(Klassentemplate)

unpack_sequence

(reflection TS)

wendet ein Template auf die Metaobjektsequenz an
(Klassentemplate)

`Named` Benannte Operationen

is_unnamed

(reflection TS)

prüft, ob die reflektierte Entität oder der Alias benannt ist
(Klassentemplate)

get_name

(reflection TS)

ermittelt den unqualifizierten Namen der reflektierten Entität oder des Alias
(Klassentemplate)

get_display_name

(reflection TS)

erhält den implementierungsdefinierten Anzeigenamen der reflektierten Entität oder des Alias
(Klassentemplate)

`Alias` Operationen

get_alias

(reflection TS)

erhält den Metaobjekt-Typ, der die assoziierte Entität des reflektierten Alias widerspiegelt
(Klassentemplate)

`Type` Operationen

get_type

(reflection TS)

erhält den Metaobjekt-Typ, der den Typ der reflektierten Entität oder des Alias reflektiert
(Klassentemplate)

get_reflected_type

(reflection TS)

ermittelt den Typ der reflektierten Entität oder des Alias
(Klassentemplate)

is_enum

(reflection TS)

prüft, ob der Metaobjekttyp einen Aufzählungstyp reflektiert
(Klassentemplate)

is_union

(reflection TS)

prüft, ob der Metaobjekttyp einen Union-Typ reflektiert
(Klassentemplate)

uses_class_key uses_struct_key

(reflection TS)

Prüft, ob der Metaobjekttyp einen Nicht-Union-Klassentyp reflektiert, dessen Deklaration class oder struct verwendet
(Klassentemplate)

`ScopeMember` Operationen

get_scope

(reflection TS)

erhält den Metaobjekt-Typ, der den Gültigkeitsbereich der reflektierten Entität oder des Alias reflektiert
(Klassentemplate)

`Base` Operationen

get_class

(reflection TS)

erhält den Metaobjekt-Typ, der die Basisklasse in der gegebenen Basisklassenbeziehung reflektiert
(Klassentemplate)

`RecordMember` und `Base` Operationen

is_public

(reflection TS)

prüft, ob das reflektierte Mitglied oder die Basisklasse öffentlich ist
(Klassentemplate)

is_protected

(reflection TS)

prüft, ob das reflektierte Mitglied oder die Basisklasse geschützt ist
(Klassentemplate)

is_private

(reflection TS)

prüft, ob das reflektierte Mitglied oder die Basisklasse privat ist
(Klassentemplate)

`Record` Operationen

get_public_data_members get_accessible_data_members get_data_members

(reflection TS)

erhält einen Metaobjekt-Sequenztyp, dessen Elemente die öffentlichen, zugreifbaren oder alle Datenelemente der reflektierten Klasse widerspiegeln
(Klassentemplate)

get_public_member_functions get_accessible_member_functions get_member_functions

(reflection TS)

erhält einen Metaobjekt-Sequenztyp, dessen Elemente öffentliche, zugreifbare oder alle Memberfunktionen der reflektierten Klasse widerspiegeln
(Klassentemplate)

get_constructors

(reflection TS)

erhält einen Metaobjekt-Sequenztyp, dessen Elemente alle Konstruktoren der reflektierten Klasse widerspiegeln
(Klassentemplate)

get_operators

(reflection TS)

erhält einen Metaobjekt-Sequenztyp, dessen Elemente alle Operatorfunktionen und Konvertierungsfunktionen widerspiegeln, die in der reflektierten Klasse deklariert sind
(Klassentemplate)

get_destructor

(reflection TS)

erhält den Metaobjekt-Typ, der den Destruktor der reflektierten Klasse widerspiegelt
(Klassen-Template)

get_public_member_types get_accessible_member_types get_member_types

(reflection TS)

erhält einen Metaobjekt-Sequenztyp, dessen Elemente öffentliche, zugreifbare oder alle geschachtelten Typen oder Member-Typdefinitionen der reflektierten Klasse widerspiegeln
(Klassentemplate)

get_public_base_classes get_accessible_base_classes get_base_classes

(reflection TS)

erhält einen Metaobjekt-Sequenztyp, dessen Elemente die öffentlichen, zugreifbaren oder alle Basisklassen der reflektierten Klasse widerspiegeln
(Klassentemplate)

`Enum` Operationen

is_scoped_enum

(reflection TS)

prüft, ob die reflektierte Aufzählung scoped ist
(Klassentemplate)

get_enumerators

(reflection TS)

erhält einen Metaobjekt-Sequenztyp, dessen Elemente die Enumeratoren der reflektierten Enumeration widerspiegeln
(Klassentemplate)

get_underlying_type

(reflection TS)

ermittelt den Metaobjekt-Typ, der den zugrundeliegenden Typ der reflektierten Aufzählung widerspiegelt
(Klassentemplate)

`Variable` Operationen

get_constant

(reflection TS)

ermittelt den Wert der reflektierten Variable, die ein konstanter Ausdruck ist
(Klassentemplate)

is_thread_local

(reflection TS)

prüft, ob die Variable mit thread_local deklariert wurde
(Klassentemplate)

`FunctionParameter` Operationen

has_default_argument

(reflection TS)

prüft, ob der reflektierte Parameter ein Standardargument besitzt
(Klassentemplate)

`Callable` Operationen

get_parameters

(reflection TS)

erhält einen Metaobjekt-Sequenztyp, dessen Elemente die Parameter der reflektierten Funktion widerspiegeln
(Klassentemplate)

is_vararg

(reflection TS)

prüft, ob die Parameterliste der reflektierten Funktion einen Ellipsen-Parameter enthält
(Klassentemplate)

is_noexcept

(reflection TS)

prüft, ob die reflektierte Funktion keine Ausnahmen wirft
(Klassentemplate)

is_deleted

(reflection TS)

prüft, ob die reflektierte Funktion gelöscht ist
(Klassentemplate)

`Variable` und `Callable` Operationen

is_constexpr

(reflection TS)

prüft, ob die reflektierte Variable oder Funktion constexpr ist
(Klassentemplate)

`Namespace` und `Callable` Operationen

is_inline

(reflection TS)

prüft, ob der reflektierte Namespace oder die Funktion inline ist
(Klassentemplate)

`ParenthesizedExpression` Operationen

get_subexpression

(reflection TS)

erhält den Metaobjekt-Typ, der den nicht geklammerten Ausdruck des reflektierten geklammerten Ausdrucks widerspiegelt
(Klassentemplate)

`FunctionCallExpression` Operationen

get_callable

(reflection TS)

erhält den Metaobjekt-Typ, der die Funktion im reflektierten function-call-expression widerspiegelt
(Klassentemplate)

`FunctionalTypeConversion` Operationen

get_constructor

(reflection TS)

erhält den Metaobjekt-Typ, der den Konstruktor in reflektiertem functional-type-conv-expression widerspiegelt
(Klassentemplate)

`Variable` und `Function` Operationen

get_pointer

(Reflection TS)

Ermittelt die Adresse der reflektierten Variable oder Funktion, oder den Zeiger-auf-Mitglied-Wert des reflektierten nicht-statischen Members
(Klassentemplate)

`MemberFunction` Operationen

is_const is_volatile has_lvalueref_qualifier has_rvalueref_qualifier

(reflection TS)

prüft, ob die reflektierte Memberfunktion mit const , volatile , & , oder && Qualifizierer deklariert wurde
(Klassentemplate)

is_override

(reflection TS)

prüft, ob die reflektierte Memberfunktion eine Memberfunktion der Basisklasse überschreibt
(Klassentemplate)

`Record` und `MemberFunction` Operationen

is_final

(reflection TS)

prüft, ob die reflektierte Klasse oder Memberfunktion mit final markiert ist
(Klassentemplate)

`Variable` und `MemberFunction` Operationen

is_static

(reflection TS)

prüft, ob die reflektierte Variable eine statische Speicherdauer hat oder die reflektierte Memberfunktion statisch ist
(Klassentemplate)

`SpecialMemberFunction` Operationen

is_implicitly_declared

(reflection TS)

prüft, ob die reflektierte spezielle Memberfunktion implizit deklariert ist
(Klassentemplate)

is_defaulted

(Reflection TS)

prüft, ob die reflektierte Spezial-Memberfunktion in ihrer ersten Deklaration als default definiert ist
(Klassentemplate)

`Constructor` und `ConversionOperator` Operationen

is_explicit

(reflection TS)

prüft, ob der reflektierte Konstruktor oder die Konvertierungsfunktion mit explicit deklariert wurde
(Klassentemplate)

`MemberFunction` und `Destructor` Operationen

is_virtual

(reflection TS)

prüft, ob die reflektierte Memberfunktion virtuell ist
(Klassentemplate)

is_pure_virtual

(reflection TS)

prüft, ob die reflektierte Memberfunktion rein virtuell ist
(Klassentemplate)

`Lambda` Operationen

get_captures

(reflection TS)

erhält einen Metaobjekt-Sequenztyp, dessen Elemente die Captures des reflektierten Closure-Typs widerspiegeln
(Klassentemplate)

uses_default_copy_capture uses_default_reference_capture

(Reflection TS)

Prüft, ob die Standarderfassung des Lambda-Ausdrucks des reflektierten Closure-Typs

oder

entspricht
(Klassentemplate)

is_call_operator_const

(reflection TS)

prüft, ob der


          operator()

des reflektierten Closure-Typs mit const deklariert ist
(Klassentemplate)

`LambdaCapture` Operationen

is_explictly_captured

(reflection TS)

prüft, ob die reflektierte Lambda-Capture explizit erfasst wurde
(Klassentemplate)

is_init_capture

(reflection TS)

prüft, ob die reflektierte Lambda-Capture eine Init-Capture ist
(Klassen-Template)

Übersicht

namespace std::experimental::reflect {
inline namespace v1 {
// 21.12.3 Konzepte für Meta-Objekt-Typen
template <class T>
concept Object = /* siehe Beschreibung */;
template <class T>
concept ObjectSequence = /* siehe Beschreibung */; // verfeinert Object
template <class T>
concept TemplateParameterScope = /* siehe Beschreibung */; // verfeinert Scope
template <class T>
concept Named = /* siehe Beschreibung */;          // verfeinert Object
template <class T>
concept Alias = /* siehe Beschreibung */;          // verfeinert Named und ScopeMember
template <class T>
concept RecordMember = /* siehe Beschreibung */;   // verfeinert ScopeMember
template <class T>
concept Enumerator = /* siehe Beschreibung */;     // verfeinert Constant
template <class T>
concept Variable = /* siehe Beschreibung */;       // verfeinert Typed und ScopeMember
template <class T>
concept ScopeMember = /* siehe Beschreibung */;    // verfeinert Named
template <class T>
concept Typed = /* siehe Beschreibung */;          // verfeinert Object
template <class T>
concept Namespace = /* siehe Beschreibung */;      // verfeinert Named und Scope
template <class T>
concept GlobalScope = /* siehe Beschreibung */;    // verfeinert Namespace
template <class T>
concept Class = /* siehe Beschreibung */;          // verfeinert Record
template <class T>
concept Enum = /* siehe Beschreibung */;           // verfeinert Type, Scope und ScopeMember
template <class T>
concept Record = /* siehe Beschreibung */;         // verfeinert Type, Scope und ScopeMember
template <class T>
concept Scope = /* siehe Beschreibung */;          // verfeinert Object
template <class T>
concept Type = /* siehe Beschreibung */;           // verfeinert Named
template <class T>
concept Constant = /* siehe Beschreibung */;       // verfeinert Typed und ScopeMember
template <class T>
concept Base = /* siehe Beschreibung */;           // verfeinert Object
template <class T>
concept FunctionParameter = /* siehe Beschreibung */; // verfeinert Typed und ScopeMember
template <class T>
concept Callable = /* siehe Beschreibung */;       // verfeinert Scope und ScopeMember
template <class T>
concept Expression = /* siehe Beschreibung */;     // verfeinert Object
template <class T>
concept ParenthesizedExpression = /* siehe Beschreibung */; // verfeinert Expression
template <class T>
concept FunctionCallExpression = /* siehe Beschreibung */; // verfeinert Expression
template <class T>
concept FunctionalTypeConversion = /* siehe Beschreibung */; // verfeinert Expression
template <class T>
concept Function = /* siehe Beschreibung */;       // verfeinert Typed und Callable
template <class T>
concept MemberFunction = /* siehe Beschreibung */; // verfeinert RecordMember und Function
template <class T>
concept SpecialMemberFunction = /* siehe Beschreibung */; // verfeinert RecordMember
template <class T>
concept Constructor = /* siehe Beschreibung */;    // verfeinert Callable und RecordMember
template <class T>
concept Destructor = /* siehe Beschreibung */;     // verfeinert Callable und SpecialMemberFunction
template <class T>
concept Operator = /* siehe Beschreibung */;       // verfeinert Function
template <class T>
concept ConversionOperator = /* siehe Beschreibung */; // verfeinert MemberFunction und Operator
template <class T>
concept Lambda = /* siehe Beschreibung */;         // verfeinert Type und Scope
template <class T>
concept LambdaCapture = /* siehe Beschreibung */;  // verfeinert Variable
// 21.12.4 Meta-Objekt-Operationen
// Multi-Concept-Operationen
template <Object T> struct is_public;
template <Object T> struct is_protected;
template <Object T> struct is_private;
template <Object T> struct is_constexpr;
template <Object T> struct is_static;
template <Object T> struct is_final;
template <Object T> struct is_explicit;
template <Object T> struct is_inline;
template <Object T> struct is_virtual;
template <Object T> struct is_pure_virtual;
template <Object T> struct get_pointer;
template <class T>
requires RecordMember<T> || Base<T>
  constexpr auto is_public_v = is_public<T>::value;
template <class T>
requires RecordMember<T> || Base<T>
  constexpr auto is_protected_v = is_protected<T>::value;
template <class T>
requires RecordMember<T> || Base<T>
  constexpr auto is_private_v = is_private<T>::value;
template <class T>
requires Variable<T> || Callable<T>
  constexpr auto is_constexpr_v = is_constexpr<T>::value;
template <class T>
requires Variable<T> || MemberFunction<T>
  constexpr auto is_static_v = is_static<T>::value;
template <class T>
requires Class<T> || MemberFunction<T>
  constexpr auto is_final_v = is_final<T>::value;
template <class T>
requires Constructor<T> || ConversionOperator<T>
  constexpr auto is_explicit_v = is_explicit<T>::value;
template <class T>
requires Namespace<T> || Callable<T>
  constexpr auto is_inline_v = is_inline<T>::value;
template <class T>
requires Base<T> || MemberFunction<T> || Destructor<T>
  constexpr auto is_virtual_v = is_virtual<T>::value;
template <class T>
requires MemberFunction<T> || Destructor<T>
  constexpr auto is_pure_virtual_v = is_pure_virtual<T>::value;
template <class T>
requires Variable<T> || Function<T>
  constexpr auto get_pointer_v = get_pointer<T>::value;
// 21.12.4.1 Objektoperationen
template <Object T1, Object T2> struct reflects_same;
template <Object T> struct get_source_line;
template <Object T> struct get_source_column;
template <Object T> struct get_source_file_name;
template <Object T1, Object T2>
  constexpr auto reflects_same_v = reflects_same<T1, T2>::value;
template <class T>
  constexpr auto get_source_line_v = get_source_line<T>::value;
template <class T>
  constexpr auto get_source_column_v = get_source_column<T>::value;
template <class T>
  constexpr auto get_source_file_name_v = get_source_file_name<T>::Wert;
// 21.12.4.2 ObjectSequence-Operationen
template <ObjectSequence T> struct get_size;
template <size_t I, ObjectSequence T> struct get_element;
template <template <class...> class Tpl, ObjectSequence T>
  struct unpack_sequence;
template <ObjectSequence T>
  constexpr auto get_size_v = get_size<T>::Wert;
template <size_t I, ObjectSequence T>
  using get_element_t = typename get_element<I, T>::type;
template <template <class...> class Tpl, ObjectSequence T>
  using unpack_sequence_t = typename unpack_sequence<Tpl, T>::type;
// 21.12.4.3 Benannte Operationen
template <Named T> struct is_unnamed;
template <Named T> struct get_name;
template <Named T> struct get_display_name;
template <Named T>
  constexpr auto is_unnamed_v = is_unnamed<T>::value;
template <Named T>
  constexpr auto get_name_v = get_name<T>::value;
template <Named T>
  constexpr auto get_display_name_v = get_display_name<T>::value;
// 21.12.4.4 Alias-Operationen
template <Alias T> struct get_aliased;
template <Alias T>
  using get_aliased_t = typename get_aliased<T>::type;
// 21.12.4.5 Typoperationen
template <Typed T> struct get_type;
template <Type T> struct get_reflected_type;
template <Type T> struct is_enum;
template <Class T> struct uses_class_key;
template <Class T> struct uses_struct_key;
template <Type T> struct is_union;
template <Typed T>
  using get_type_t = typename get_type<T>::type;
template <Type T>
  using get_reflected_type_t = typename get_reflected_type<T>::type;
template <Type T>
  constexpr auto is_enum_v = is_enum<T>::value;
template <Class T>
  constexpr auto uses_class_key_v = uses_class_key<T>::value;
template <Class T>
  constexpr auto uses_struct_key_v = uses_struct_key<T>::value;
template <Type T>
  constexpr auto is_union_v = is_union<T>::value;
// 21.12.4.6 Member operations
template <ScopeMember T> struct get_scope;
template <RecordMember T> struct is_public<T>;
template <RecordMember T> struct is_protected<T>;
template <RecordMember T> struct is_private<T>;
template <ScopeMember T>
  using get_scope_t = typename get_scope<T>::type;
// 21.12.4.7 Datensatzoperationen
template <Record T> struct get_public_data_members;
template <Record T> struct get_accessible_data_members;
template <Record T> struct get_data_members;
template <Record T> struct get_public_member_functions;
template <Record T> struct get_accessible_member_functions;
template <Record T> struct get_member_functions;
template <Record T> struct get_public_member_types;
template <Record T> struct get_accessible_member_types;
template <Record T> struct get_member_types;
template <Record T> struct get_constructors;
template <Record T> struct get_destructor;
template <Record T> struct get_operators;
template <Class T> struct get_public_base_classes;
template <Class T> struct get_accessible_base_classes;
template <Class T> struct get_base_classes;
template <Class T> struct is_final<T>;
template <Record T>
  using get_public_data_members_t = typename get_public_data_members<T>::type;
template <Record T>
  using get_accessible_data_members_t = typename get_accessible_data_members<T>::type;
template <Record T>
  using get_data_members_t = typename get_data_members<T>::type;
template <Record T>
  using get_public_member_functions_t = typename get_public_member_functions<T>::type;
template <Record T>
  using get_accessible_member_functions_t = typename get_accessible_member_functions<T>::type;
template <Record T>
  using get_member_functions_t = typename get_member_functions<T>::type;
template <Record T>
  using get_public_member_types_t = typename get_public_member_types<T>::type;
template <Record T>
  using get_accessible_member_types_t = typename get_accessible_member_types<T>::type;
template <Record T>
  using get_member_types_t = typename get_member_types<T>::type;
template <Record T>
  using get_constructors_t = typename get_constructors<T>::type;
template <Record T>
  using get_destructor_t = typename get_destructor<T>::type;
template <Record T>
  using get_operators_t = typename get_operators<T>::type;
template <Class T>
  using get_public_base_classes_t = typename get_public_base_classes<T>::type;
template <Class T>
  using get_accessible_base_classes_t = typename get_accessible_base_classes<T>::type;
template <Class T>
  using get_base_classes_t = typename get_base_classes<T>::type;
// 21.12.4.8 Enum-Operationen
template <Enum T> struct is_scoped_enum;
template <Enum T> struct get_enumerators;
template <Enum T> struct get_underlying_type;
template <Enum T>
  constexpr auto is_scoped_enum_v = is_scoped_enum<T>::value;
template <Enum T>
  using get_enumerators_t = typename get_enumerators<T>::type;
template <Enum T>
  using get_underlying_type_t = typename get_underlying_type<T>::type;
// 21.12.4.9 Wertoperationen
template <Constant T> struct get_constant;
template <Variable T> struct is_constexpr<T>;
template <Variable T> struct is_static<T>;
template <Variable T> struct is_thread_local;
template <Variable T> struct get_pointer<T>;
template <Constant T>
  constexpr auto get_constant_v = get_constant<T>::value;
template <Variable T>
  constexpr auto is_thread_local_v = is_thread_local<T>::value;
// 21.12.4.10 Basisfunktionen
template <Base T> struct get_class;
template <Base T> struct is_virtual<T>;
template <Base T> struct is_public<T>;
template <Base T> struct is_protected<T>;
template <Base T> struct is_private<T>;
template <Base T>
  using get_class_t = typename get_class<T>::type;
// 21.12.4.11 Namespace-Operationen
template <Namespace T> struct is_inline<T>;
// 21.12.4.12 FunctionParameter-Operationen
template <FunctionParameter T> struct has_default_argument;
template <FunctionParameter T>
  constexpr auto has_default_argument_v = has_default_argument<T>::value;
// 21.12.4.13 Aufrufbare Operationen
template <Callable T> struct get_parameters;
template <Callable T> struct is_vararg;
template <Callable T> struct is_constexpr<T>;
template <Callable T> struct is_noexcept;
template <Callable T> struct is_inline<T>;
template <Callable T> struct is_deleted;
template <Callable T>
  using get_parameters_t = typename get_parameters<T>::type;
template <Callable T>
  constexpr auto is_vararg_v = is_vararg<T>::value;
template <Callable T>
  constexpr auto is_deleted_v = is_deleted<T>::value;
// 21.12.4.14 ParenthesizedExpression-Operationen
template <ParenthesizedExpression T> struct get_subexpression;
template <ParenthesizedExpression T>
  using get_subexpression_t = typename get_subexpression<T>::type;
// 21.12.4.15 FunctionCallExpression-Operationen
template <FunctionCallExpression T> struct get_callable;
template <FunctionCallExpression T>
  using get_callable_t = typename get_callable<T>::type;
// 21.12.4.16 FunctionalTypeConversion-Operationen
template <FunctionalTypeConversion T> struct get_constructor;
template <FunctionalTypeConversion T>
  using get_constructor_t = typename get_constructor<T>::type;
// 21.12.4.17 Funktionsoperationen
template <Function T> struct get_pointer<T>;
// 21.12.4.18 MemberFunction Operationen
template <MemberFunction T> struct is_static<T>;
template <MemberFunction T> struct is_const;
template <MemberFunction T> struct is_volatile;
template <MemberFunction T> struct has_lvalueref_qualifier;
template <MemberFunction T> struct has_rvalueref_qualifier;
template <MemberFunction T> struct is_virtual<T>;
template <MemberFunction T> struct is_pure_virtual<T>;
template <MemberFunction T> struct is_override;
template <MemberFunction T> struct is_final<T>;
template <MemberFunction T>
  constexpr auto is_const_v = is_const<T>::Wert;
template <MemberFunction T>
  constexpr auto is_volatile_v = is_volatile<T>::value;
template <MemberFunction T>
  constexpr auto has_lvalueref_qualifier_v = has_lvalueref_qualifier<T>::value;
template <MemberFunction T>
  constexpr auto has_rvalueref_qualifier_v = has_rvalueref_qualifier<T>::Wert;
template <MemberFunction T>
  constexpr auto is_override_v = is_override<T>::value;
// 21.12.4.19 SpecialMemberFunction Operationen
template <SpecialMemberFunction T> struct is_implicitly_declared;
template <SpecialMemberFunction T> struct is_defaulted;
template <SpecialMemberFunction T>
  constexpr auto is_implicitly_declared_v = is_implicitly_declared<T>::Wert;
template <SpecialMemberFunction T>
  constexpr auto is_defaulted_v = is_defaulted<T>::Wert;
// 21.12.4.20 Konstruktoroperationen
template <Constructor T> struct is_explicit<T>;
// 21.12.4.21 Destruktoroperationen
template <Destructor T> struct is_virtual<T>;
template <Destructor T> struct is_pure_virtual<T>;
// 21.12.4.22 ConversionOperator-Operationen
template <ConversionOperator T> struct is_explicit<T>;
// 21.12.4.23 Lambda-Operationen
template <Lambda T> struct get_captures;
template <Lambda T> struct uses_default_copy_capture;
template <Lambda T> struct uses_default_reference_capture;
template <Lambda T> struct is_call_operator_const;
template <Lambda T>
  using get_captures_t = typename get_captures<T>::type;
template <Lambda T>
  constexpr auto uses_default_copy_capture_v = uses_default_copy_capture<T>::Wert;
template <Lambda T>
  constexpr auto uses_default_reference_capture_v = uses_default_reference_capture<T>::Wert;
template <Lambda T>
  constexpr auto is_call_operator_const_v = is_call_operator_const<T>::value;
// 21.12.4.24 LambdaCapture-Operationen
template <LambdaCapture T> struct is_explicitly_captured;
template <LambdaCapture T> struct is_init_capture;
template <LambdaCapture T>
  constexpr auto is_explicitly_captured_v = is_explicitly_captured<T>::value;
template <LambdaCapture T>
  constexpr auto is_init_capture_v = is_init_capture<T>::value;
} // inline namespace v1
} // namespace std::experimental::reflect

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

Experimental library header <experimental/reflect>

Inhaltsverzeichnis

Konzepte

Klassen

`Object` Operationen

`ObjectSequence` Operationen

`Named` Benannte Operationen

`Alias` Operationen

`Type` Operationen

`ScopeMember` Operationen

`Base` Operationen

`RecordMember` und `Base` Operationen

`Record` Operationen

`Enum` Operationen

`Variable` Operationen

`FunctionParameter` Operationen

`Callable` Operationen

`Variable` und `Callable` Operationen

`Namespace` und `Callable` Operationen

`ParenthesizedExpression` Operationen

`FunctionCallExpression` Operationen

`FunctionalTypeConversion` Operationen

`Variable` und `Function` Operationen

`MemberFunction` Operationen

`Record` und `MemberFunction` Operationen

`Variable` und `MemberFunction` Operationen

`SpecialMemberFunction` Operationen

`Constructor` und `ConversionOperator` Operationen

`MemberFunction` und `Destructor` Operationen

`Lambda` Operationen

`LambdaCapture` Operationen

Übersicht

cppreference.net

Namespaces

Variants

Experimental library header <experimental/reflect>

Inhaltsverzeichnis

Konzepte

Klassen

Object Operationen

ObjectSequence Operationen

Named Benannte Operationen

Alias Operationen

Type Operationen

ScopeMember Operationen

Base Operationen

RecordMember und Base Operationen

Record Operationen

Enum Operationen

Variable Operationen

FunctionParameter Operationen

Callable Operationen

Variable und Callable Operationen

Namespace und Callable Operationen

ParenthesizedExpression Operationen

FunctionCallExpression Operationen

FunctionalTypeConversion Operationen

Variable und Function Operationen

MemberFunction Operationen

Record und MemberFunction Operationen

Variable und MemberFunction Operationen

SpecialMemberFunction Operationen

Constructor und ConversionOperator Operationen

MemberFunction und Destructor Operationen

Lambda Operationen

LambdaCapture Operationen

Übersicht

`Object` Operationen

`ObjectSequence` Operationen

`Named` Benannte Operationen

`Alias` Operationen

`Type` Operationen

`ScopeMember` Operationen

`Base` Operationen

`RecordMember` und `Base` Operationen

`Record` Operationen

`Enum` Operationen

`Variable` Operationen

`FunctionParameter` Operationen

`Callable` Operationen

`Variable` und `Callable` Operationen

`Namespace` und `Callable` Operationen

`ParenthesizedExpression` Operationen

`FunctionCallExpression` Operationen

`FunctionalTypeConversion` Operationen

`Variable` und `Function` Operationen

`MemberFunction` Operationen

`Record` und `MemberFunction` Operationen

`Variable` und `MemberFunction` Operationen

`SpecialMemberFunction` Operationen

`Constructor` und `ConversionOperator` Operationen

`MemberFunction` und `Destructor` Operationen

`Lambda` Operationen

`LambdaCapture` Operationen