Extensions for reflection
Die C++-Erweiterungen für Reflection, ISO/IEC TS 23619:2021, spezifizieren Modifikationen an der Kernsprache und definieren neue Komponenten für die C++-Standardbibliothek, die auf dieser Seite aufgelistet sind.
Das Reflection TS basiert auf dem C++20-Standard (mit Ausnahme, dass die Definition von Concepts im Stil des Concepts TS spezifiziert ist).
Kernsprachänderungen
reflexpr-Spezifizierer
Ein
reflexpr-specifier
hat die Form
reflexpr
(
reflexpr-operand
)
und spezifiziert einen Metaobjekt-Typ (siehe unten).
reflexpr-operand kann einer der folgenden sein:
::
|
(1) | ||||||||
| Typ-ID | (2) | ||||||||
| Verschachtelter-Namensspezifizierer (optional) Namensraum-Name | (3) | ||||||||
| ID-Ausdruck | (4) | ||||||||
(
Ausdruck
)
|
(5) | ||||||||
| Funktionsaufruf-Ausdruck | (6) | ||||||||
| Funktionale-Typkonvertierungs-Ausdruck | (7) | ||||||||
wo function-call-expression ist
Postfix-Ausdruck
(
Ausdrucksliste
(optional)
)
|
|||||||||
und functional-type-conv-expression sind folgende Arten von Ausdrücken, die eine explizite Konvertierung durchführen:
simple-type-specifier
(
expression-list
(optional)
)
|
(1) | ||||||||
typename-specifier
(
expression-list
(optional)
)
|
(2) | ||||||||
| simple-type-specifier braced-init-list | (3) | ||||||||
| typename-specifier braced-init-list | (4) | ||||||||
Der Operand des reflexpr-Spezifizierers muss ein Typ , Namensraum , Enumerator , eine Variable, Datenelement , Funktionsparameter , erfasste Entität , Funktionsaufrufausdruck oder funktionaler Typumwandlungsausdruck sowie ein geklammerter Ausdruck sein. reflexpr ( :: ) reflektiert den globalen Namensraum.
Für einen
reflexpr-Operanden
der Form
(
Ausdruck
)
muss der
Ausdruck
ein (möglicherweise mehrfach geklammerter)
Funktionsaufrufausdruck
oder
funktionaler Typkonvertierungsausdruck
sein.
Wenn ein nicht in Klammern gesetzter Operand entweder als
type-id
oder als
functional-type-conv-expression
behandelt werden kann, wird er als
type-id
behandelt. Klammern können zur Unterscheidung zwischen Funktions-Stil-Cast und einer
type-id
verwendet werden. Beispielsweise reflektiert für einen Klassentyp
X
mit Standardkonstruktor
reflexpr
(
X
(
)
)
den Funktionstyp
X
(
)
, und
reflexpr
(
(
X
(
)
)
)
reflektiert den Ausdruck
X
(
)
.
Wenn der Operand sowohl einen Alias als auch einen Klassennamen bezeichnet, spiegelt der durch den Reflexpr-Spezifizierer repräsentierte Typ den Alias wider und erfüllt
reflect::Alias
.
Wenn der Operand einen Namen bezeichnet, dessen Deklaration in einen Blockgültigkeitsbereich eingeschlossen ist und die benannte Entität weder erfasst noch ein Funktionsparameter ist, ist das Programm fehlerhaft.
Meta-Objekttypen
Ein
Meta-Objekt-Typ
ist ein unbenannter, unvollständiger Namespace-Bereich-Klassentyp. Ein Typ erfüllt das Konzept
reflect::Object
genau dann, wenn es sich um einen Meta-Objekt-Typ handelt. Meta-Objekt-Typen können weitere Konzepte erfüllen, abhängig vom Operanden von
reflexpr
.
Es ist nicht spezifiziert, ob wiederholtes Anwenden von
reflexpr
auf denselben Operanden denselben Typ oder einen anderen Typ ergibt. Wenn ein Metaobjekttyp einen unvollständigen Klassentyp reflektiert, können bestimmte Typumwandlungen nicht angewendet werden.
Ein Meta-Objekt-Typ ermöglicht die Überprüfung einiger Eigenschaften des Operanden von
reflexpr
durch Type Traits oder Typ-Transformationen an ihm.
Überladenauflösung
Wenn der Postfix-Ausdruck des Funktionsaufrufausdrucks vom Klassentyp ist, d.h. e im Funktionsaufrufausdruck e ( args ) vom Klassentyp ist, dann darf die benutzerdefinierte Konvertierungsfunktion des Typs des Postfix-Ausdrucks ( e ) nicht verwendet werden.
Wenn postfix-expression kein Klassentyp ist, muss sie eine Funktion benennen, die das eindeutige Ergebnis der Überladungsauflösung ist.
struct Functor { void operator()(int) const; using fptr_t = void(*)(std::nullptr_t); operator fptr_t() const; }; using Meta0 = reflexpr(Functor{}(0)); // OK // using Meta1 = reflexpr(Functor{}(nullptr)); // Fehler: Konvertierungsfunktion verwendet
Ein Alias ist ein Name, der durch eine typedef -Deklaration, eine Alias-Deklaration oder eine using-Deklaration eingeführt wird.
Eine Entität oder ein Alias
B
ist
reflektionsbezogen
zu einer Entität oder einem Alias
A
wenn
-
AundBsind dieselbe Entität oder ein Alias, -
Aist eine Variable oder ein Enumerator undBist der Typ vonA, -
Aist eine Enumeration undBist der zugrundeliegende Typ vonA, -
Aist eine Klasse undBist ein Member oder eine Basisklasse vonA, -
Aist ein Nicht-Template-Alias, der die EntitätBbezeichnet, -
Aist nicht der globale Namensraum undBist eine umschließende Klasse oder ein umschließender Namensraum vonA, -
Aist der geklammerte Ausdruck (B), -
Aist ein Lambda-Capture des Closure-TypsB, -
Aist der Closure-Typ des Lambda-CapturesB, -
Bist der durch den functional-type-conv-expressionAspezifizierte Typ, -
Bist die durch Overload-Resolution für einen function-call-expressionAausgewählte Funktion, -
Bist der Rückgabetyp, ein Parametertyp oder der Funktionstyp der FunktionA, oder -
Bist reflexionsbezogen zu einer Entität oder einem AliasXundXist reflexionsbezogen zuA.
Die Reflexions-Relationsbeziehung ist reflexiv und transitiv, aber nicht symmetrisch.
Informell gesprochen bedeutet der Fall, dass
B
reflexionsbezogen zu
A
ist, dass
B
an der Deklaration oder Definition von
A
beteiligt ist.
Null oder mehrere aufeinanderfolgende Anwendungen von Typumwandlungen, die Metaobjekttypen ergeben, auf den durch einen reflexpr-specifier bezeichneten Typ ermöglichen die Untersuchung von Entitäten und Aliasen, die reflexionsbezogen zum Operanden sind; ein solcher Metaobjekttyp wird als reflektierend für die jeweilige reflexionsbezogene Entität oder den Alias bezeichnet.
struct X; struct B { using X = ::X; typedef X Y; }; struct D : B { using B::Y; }; // Nur ::X, nicht B::X oder B::Y ist reflexionsbezogen zu D::Y
Sonstiges
- Ein als reflexpr-Operand verwendeter Ausdruck ist ein nicht ausgewerteter Ausdruck und wird potenziell konstant ausgewertet .
-
Für die Bestimmung von Variablen,
die in einem Lambda-Ausdruck erfasst werden
durch eine Standarderfassung, wird ein
reflexpr-Operand nicht als nicht ausgewerteter Operand betrachtet. -
Eine Funktion oder Variable mit statischer
Speicherdauer
, die durch den Metaobjekttyp
Treflektiert wird, wird durch die Spezialisierung std :: experimental :: reflect :: get_pointer < T > odr-verwendet, als würde die Adresse eines die Funktion oder Variable benennenden ID-Ausdrucks genommen. - Es kann mehr als eine Definition eines Metaobjekttyps geben, solange alle Operationen auf diesem Typ dieselben konstanten Ausdrucksergebnisse liefern.
-
Ein Typ ist
abhängig
, wenn er durch einen Reflexpr-Spezifizierer bezeichnet wird und der Operand
- ein typabhängiger Ausdruck oder ein (möglicherweise in Klammern gesetzter) Funktionstyp-Konvertierungsausdruck mit mindestens einem typabhängigen unmittelbaren Teilausdruck ist, oder
- einen abhängigen Typ oder ein Mitglied einer unbekannten Spezialisierung oder einen wertabhängigen konstanten Ausdruck bezeichnet.
Schlüsselwörter
Vordefinierte Feature-Test-Makros
|
__cpp_reflection
(reflection TS)
|
Ein Wert von mindestens
201902
zeigt an, dass der Reflection TS unterstützt wird
(Makrokonstante) |
Bibliotheksunterstützung
Konzepte
|
Definiert im Header
<experimental/reflect>
|
|
|
Definiert in namespace
std::experimental::reflect
|
|
|
Definiert im Inline-Namespace
std::experimental::reflect::v1
|
|
|
(reflection TS)
|
spezifiziert, dass ein Typ ein Metaobjekt-Typ ist
(concept) |
|
(reflection TS)
|
spezifiziert, dass ein Metaobjekt-Typ ein Metaobjekt-Sequenz-Typ ist
(Konzept) |
|
(reflection TS)
|
gibt an, dass ein Metaobjekttyp einen Template-Parameterbereich reflektiert
(Konzept) |
|
(reflection TS)
|
spezifiziert, dass ein Metaobjekttyp eine Entität oder einen Alias mit einem zugehörigen (möglicherweise leeren) Namen reflektiert
(Konzept) |
|
(reflection TS)
|
spezifiziert, dass ein Metaobjekttyp einen Typalias, Namensraumalias oder einen durch eine using-Deklaration eingeführten Alias reflektiert
(Konzept) |
|
(reflection TS)
|
spezifiziert, dass ein Metaobjekttyp eine
member-declaration
einer Klasse reflektiert
(Konzept) |
|
(reflection TS)
|
spezifiziert, dass ein Metaobjekttyp einen Enumerator reflektiert
(Konzept) |
|
(reflection TS)
|
spezifiziert, dass ein Metaobjekttyp eine Variable oder ein Datenelement reflektiert
(Konzept) |
|
(Reflection TS)
|
spezifiziert, dass ein Metaobjekt-Typ
RecordMember
,
Enumerator
oder
Variable
erfüllt, oder einen Namespace außer dem globalen Namespace reflektiert
(Konzept) |
|
(reflection TS)
|
spezifiziert, dass ein Metaobjekttyp eine Entität mit einem Typ reflektiert
(Konzept) |
|
(reflection TS)
|
gibt an, dass ein Metaobjekttyp einen Namespace reflektiert
(Konzept) |
|
(reflection TS)
|
spezifiziert, dass ein Metaobjekt-Typ den globalen Namensraum reflektiert
(Konzept) |
|
(reflection TS)
|
gibt an, dass ein Metaobjekttyp einen Nicht-Union-Klassentyp reflektiert
(Konzept) |
|
(reflection TS)
|
gibt an, dass ein Metaobjekttyp einen Aufzählungstyp reflektiert
(Konzept) |
|
(reflection TS)
|
spezifiziert, dass ein Metaobjekttyp einen Klassentyp reflektiert
(Konzept) |
|
(reflection TS)
|
gibt an, dass ein Metaobjekttyp einen Namespace, eine Klasse, eine Enumeration, eine Funktion, einen Closure-Typ oder einen Template-Parameter-Bereich reflektiert
(concept) |
|
(reflection TS)
|
gibt an, dass ein Metaobjekttyp einen Typ reflektiert
(Konzept) |
|
(reflection TS)
|
gibt an, dass ein Metaobjekttyp einen Enumerator oder eine constexpr-Variable reflektiert
(Konzept) |
|
(reflection TS)
|
spezifiziert, dass ein Metaobjekttyp eine direkte Basisklasse widerspiegelt, die von
get_base_classes
erhalten wurde
(Konzept) |
|
(reflection TS)
|
gibt an, dass ein Metaobjekttyp einen Funktionsparameter reflektiert
(Konzept) |
|
(reflection TS)
|
gibt an, dass ein Metaobjekttyp eine Funktion reflektiert (einschließlich Konstruktoren und Destruktoren)
(Konzept) |
|
(reflection TS)
|
gibt an, dass ein Metaobjekttyp einen Ausdruck reflektiert
(Konzept) |
|
(reflection TS)
|
spezifiziert, dass ein Metaobjekt-Typ einen geklammerten Ausdruck reflektiert
(Konzept) |
|
(reflection TS)
|
gibt an, dass ein Metaobjekttyp einen
function-call-expression
reflektiert
(Konzept) |
|
(reflection TS)
|
gibt an, dass ein Metaobjekttyp einen
functional-type-conv-expression
reflektiert
(Konzept) |
|
(reflection TS)
|
gibt an, dass ein Metaobjekttyp eine Funktion reflektiert (ausgenommen Konstruktoren und Destruktoren)
(Konzept) |
|
(reflection TS)
|
gibt an, dass ein Metaobjekttyp eine Memberfunktion widerspiegelt (ausgenommen Konstruktoren und Destruktoren)
(Konzept) |
|
(reflection TS)
|
gibt an, dass ein Metaobjekttyp eine spezielle Memberfunktion reflektiert
(Konzept) |
|
(reflection TS)
|
gibt an, dass ein Metaobjekttyp einen Konstruktor reflektiert
(Konzept) |
|
(reflection TS)
|
gibt an, dass ein Metaobjekttyp einen Destruktor reflektiert
(Konzept) |
|
(reflection TS)
|
gibt an, dass ein Metaobjekttyp eine Operatorfunktion oder eine Konvertierungsfunktion reflektiert
(Konzept) |
|
(reflection TS)
|
gibt an, dass ein Metaobjekttyp eine Konvertierungsfunktion reflektiert
(Konzept) |
|
(reflection TS)
|
gibt an, dass ein Metaobjekttyp den Closure-Typ eines nicht-generischen Lambda reflektiert
(Konzept) |
|
(reflection TS)
|
gibt an, dass ein Metaobjekttyp eine Lambda-Capture reflektiert
(Konzept) |
Meta-Objekt-Operationen
|
Definiert im Header
<experimental/reflect>
|
|
|
Definiert in namespace
std::experimental::reflect
|
|
|
Definiert im Inline-Namespace
std::experimental::reflect::v1
|
|
|
|
|
(reflection TS)
|
prüft, ob zwei Metaobjekttypen dieselbe Entität oder denselben Alias reflektieren
(Klassentemplate) |
|
(reflection TS)
|
ermittelt die vermutliche Zeilennummer der Deklaration der reflektierten Entität oder des Alias
(Klassentemplate) |
|
(reflection TS)
|
Ermittelt die implementierungsdefinierte Spaltennummer der Deklaration der reflektierten Entität oder des Alias
(Klassentemplate) |
|
(reflection TS)
|
ermittelt den vermuteten Dateinamen der Deklaration der reflektierten Entität oder des Alias
(Klassentemplate) |
|
|
|
(reflection TS)
|
ermittelt die Größe einer Metaobjekt-Sequenz
(Klassentemplate) |
|
(reflection TS)
|
erhält den Metaobjekt-Typ mit angegebenem Index in einer Sequenz
(Klassentemplate) |
|
(reflection TS)
|
wendet ein Template auf die Metaobjektsequenz an
(Klassentemplate) |
|
|
|
(reflection TS)
|
prüft, ob die reflektierte Entität oder der Alias unbenannt ist
(Klassentemplate) |
|
(reflection TS)
|
ermittelt den unqualifizierten Namen der reflektierten Entität oder des Alias
(Klassentemplate) |
|
(reflection TS)
|
ermittelt den implementierungsdefinierten Anzeigenamen der reflektierten Entität oder des Alias
(Klassentemplate) |
|
|
|
(reflection TS)
|
erhält den Metaobjekt-Typ, der die assoziierte Entität des reflektierten Alias widerspiegelt
(Klassentemplate) |
|
|
|
(Reflection TS)
|
erhält den Metaobjekt-Typ, der den Typ der reflektierten Entität oder des Alias reflektiert
(Klassentemplate) |
|
(reflection TS)
|
ermittelt den Typ der reflektierten Entität oder des Alias
(Klassentemplate) |
|
(reflection TS)
|
prüft, ob der Metaobjekttyp einen Aufzählungstyp reflektiert
(Klassentemplate) |
|
(reflection TS)
|
prüft, ob der Metaobjekttyp einen Union-Typ reflektiert
(Klassentemplate) |
|
(reflection TS)
|
prüft, ob der Metaobjekt-Typ einen Nicht-Union-Klassentyp widerspiegelt, dessen Deklaration
class
oder
struct
verwendet
(Klassentemplate) |
|
|
|
(reflection TS)
|
erhält den Metaobjekt-Typ, der den Gültigkeitsbereich der reflektierten Entität oder des Alias reflektiert
(Klassentemplate) |
|
|
|
(reflection TS)
|
erhält den Metaobjekt-Typ, der die Basisklasse in der gegebenen Basisklassenbeziehung reflektiert
(Klassentemplate) |
|
|
|
(reflection TS)
|
prüft, ob das reflektierte Mitglied oder die Basisklasse öffentlich ist
(Klassentemplate) |
|
(reflection TS)
|
prüft, ob die reflektierte Member- oder Basisklasse geschützt ist
(Klassentemplate) |
|
(reflection TS)
|
prüft, ob das reflektierte Mitglied oder die Basisklasse privat ist
(Klassentemplate) |
|
|
|
erhält einen Metaobjekt-Sequenztyp, dessen Elemente die öffentlichen, zugreifbaren oder alle Datenelemente der reflektierten Klasse widerspiegeln
(Klassentemplate) |
|
|
erhält einen Metaobjekt-Sequenztyp, dessen Elemente öffentliche, zugreifbare oder alle Memberfunktionen der reflektierten Klasse widerspiegeln
(Klassentemplate) |
|
|
(reflection TS)
|
erhält einen Metaobjekt-Sequenztyp, dessen Elemente alle Konstruktoren der reflektierten Klasse widerspiegeln
(Klassentemplate) |
|
(reflection TS)
|
erhält einen Metaobjekt-Sequenztyp, dessen Elemente alle Operatorfunktionen und Konvertierungsfunktionen widerspiegeln, die in der reflektierten Klasse deklariert sind
(Klassentemplate) |
|
(reflection TS)
|
erhält den Metaobjekt-Typ, der den Destruktor der reflektierten Klasse widerspiegelt
(Klassen-Template) |
|
erhält einen Metaobjekt-Sequenztyp, dessen Elemente öffentliche, zugreifbare oder alle geschachtelten Typen oder Member-Typedefs der reflektierten Klasse widerspiegeln
(Klassentemplate) |
|
|
erhält eine Metaobjekt-Sequenz, deren Elemente die öffentlichen, zugreifbaren oder alle Basisklassen der reflektierten Klasse widerspiegeln
(Klassentemplate) |
|
|
|
|
(reflection TS)
|
prüft, ob die reflektierte Aufzählung scoped ist
(Klassentemplate) |
|
(reflection TS)
|
erhält einen Metaobjekt-Sequenztyp, dessen Elemente die Enumeratoren der reflektierten Enumeration widerspiegeln
(Klassentemplate) |
|
(reflection TS)
|
ermittelt den Metaobjekttyp, der den zugrundeliegenden Typ der reflektierten Aufzählung widerspiegelt
(Klassentemplate) |
|
|
|
(reflection TS)
|
ermittelt den Wert der reflektierten Variable, die ein konstanter Ausdruck ist
(Klassentemplate) |
|
(reflection TS)
|
prüft, ob die Variable mit
thread_local
deklariert wurde
(Klassentemplate) |
|
|
|
(reflection TS)
|
prüft, ob der reflektierte Parameter ein Standardargument besitzt
(Klassentemplate) |
|
|
|
(reflection TS)
|
erhält einen Metaobjekt-Sequenztyp, dessen Elemente die Parameter der reflektierten Funktion widerspiegeln
(Klassentemplate) |
|
(reflection TS)
|
prüft, ob die Parameterliste der reflektierten Funktion einen Ellipsen-Parameter enthält
(Klassentemplate) |
|
(reflection TS)
|
prüft, ob die reflektierte Funktion keine Ausnahmen wirft
(Klassentemplate) |
|
(reflection TS)
|
prüft, ob die reflektierte Funktion gelöscht ist
(Klassentemplate) |
|
|
|
(reflection TS)
|
prüft, ob die reflektierte Variable oder Funktion constexpr ist
(Klassentemplate) |
|
|
|
(reflection TS)
|
prüft, ob der reflektierte Namespace oder die Funktion inline ist
(Klassentemplate) |
|
|
|
(reflection TS)
|
erhält den Metaobjekt-Typ, der den nicht geklammerten Ausdruck des reflektierten geklammerten Ausdrucks widerspiegelt
(Klassentemplate) |
|
|
|
(reflection TS)
|
erhält den Metaobjekt-Typ, der die Funktion im reflektierten
function-call-expression
widerspiegelt
(Klassentemplate) |
|
|
|
(reflection TS)
|
erhält den Metaobjekt-Typ, der den Konstruktor in reflektiertem
functional-type-conv-expression
widerspiegelt
(Klassentemplate) |
|
|
|
(reflection TS)
|
Ermittelt die Adresse der reflektierten Variable oder Funktion, oder den Zeiger-auf-Mitglied-Wert des reflektierten nicht-statischen Members
(Klassentemplate) |
|
|
|
prüft, ob die reflektierte Memberfunktion mit
const
,
volatile
,
&
, oder
&&
Qualifizierer deklariert wurde
(Klassentemplate) |
|
|
(reflection TS)
|
prüft, ob die reflektierte Memberfunktion eine Memberfunktion der Basisklasse überschreibt
(Klassentemplate) |
|
|
|
(reflection TS)
|
prüft, ob die reflektierte Klasse oder Memberfunktion als
final
markiert ist
(Klassentemplate) |
|
|
|
(reflection TS)
|
prüft, ob die reflektierte Variable eine statische Speicherdauer hat oder die reflektierte Memberfunktion statisch ist
(Klassentemplate) |
|
|
|
(reflection TS)
|
prüft, ob die reflektierte spezielle Memberfunktion implizit deklariert ist
(Klassentemplate) |
|
(reflection TS)
|
prüft, ob die reflektierte Spezial-Memberfunktion in ihrer ersten Deklaration als default definiert ist
(Klassentemplate) |
|
|
|
(reflection TS)
|
prüft, ob der reflektierte Konstruktor oder die Konvertierungsfunktion mit
explicit
deklariert wurde
(Klassentemplate) |
|
|
|
(Reflection TS)
|
prüft, ob die reflektierte Memberfunktion virtuell ist
(Klassentemplate) |
|
(reflection TS)
|
prüft, ob die reflektierte Memberfunktion rein virtuell ist
(Klassentemplate) |
|
|
|
(reflection TS)
|
erhält einen Metaobjekt-Sequenztyp, dessen Elemente die Captures des reflektierten Closure-Typs widerspiegeln
(Klassentemplate) |
|
(Reflection TS)
|
Prüft, ob die Standarderfassung des Lambda-Ausdrucks des reflektierten Closure-Typs
=
oder
&
entspricht
(Klassentemplate) |
|
(reflection TS)
|
prüft, ob der
operator()
des reflektierten Closure-Typs mit
const
deklariert ist
(Klassentemplate) |
|
|
|
(reflection TS)
|
prüft, ob die reflektierte Lambda-Capture explizit erfasst wurde
(Klassentemplate) |
|
(reflection TS)
|
prüft, ob die reflektierte Lambda-Aufnahme eine Init-Aufnahme ist
(Klassentemplate) |
Bibliotheks-Feature-Test-Makros
|
Definiert in Header
<experimental/reflect>
|
|
|
__cpp_lib_reflection
(reflection TS)
|
ein Wert von mindestens
201902
zeigt an, dass die Unterstützungsbibliothek des Reflection TS unterstützt wird
(Makrokonstante) |
Erfüllung von Konzepten
Die folgende Tabelle zeigt, ob ein Metaobjekttyp, der einen Operanden reflektiert, die vom Reflection TS eingeführten Konzepte erfüllt.
| Kategorie |
reflexpr
Operanden
|
Erfüllte Konzepte |
|---|---|---|
| Typ | class-name die eine union bezeichnet |
reflect::Union
|
| class-name die einen closure type bezeichnet |
reflect::Lambda
|
|
| class-name die eine Nicht-Union-Klasse bezeichnet |
reflect::Record
|
|
| enum-name |
reflect::Enum
|
|
| template type-parameter |
reflect::Type
,
reflect::Alias
|
|
| decltype-specifier |
reflect::Type
,
reflect::Alias
|
|
| type-name eingeführt durch eine using-declaration |
reflect::Type
,
reflect::Alias
,
reflect::ScopedMember
|
|
| jeder andere typedef-name |
reflect::Type
,
reflect::Alias
|
|
| jede andere type-id |
reflect::Type
|
|
| Namespace | namespace-alias |
reflect::Namespace
,
reflect::Alias
|
| der globale Namespace |
reflect::GlobalScope
|
|
| jeder andere namespace |
reflect::Namespace
|
|
| Ausdruck | der Name eines Datenelements |
reflect::Variable
|
| der Name einer Variable |
reflect::Variable
|
|
| der Name eines Enumerators |
reflect::Enumerator
|
|
| der Name eines Funktionsparameters |
reflect::FunctionParameter
|
|
| der Name einer captured entity |
reflect::LambdaCapture
|
|
| geklammerter Ausdruck |
reflect::ParenthesizedExpression
|
|
| function-call-expression |
reflect::FunctionCallExpression
|
|
| functional-type-conv-expression |
reflect::FunctionalTypeConversion
|
Wenn der Operand der Form id-Ausdruck ein konstanter Ausdruck ist, erfüllt der durch den Reflexpr-Spezifizierer angegebene Typ ebenfalls
reflect::Constant
.
Wenn der reflexpr-Operand ein Klassenmitglied bezeichnet, erfüllt der durch die reflexpr-Spezifikation repräsentierte Typ ebenfalls
reflect::RecordMember
.
Siehe auch
|
enthält Informationen über einen Typ, die Klasse, die vom typeid-Operator zurückgegeben wird
(Klasse) |
|
|
(C++11)
|
Dienstprogramme für Typinformationen zur Übersetzungszeit |