Enumerationsklasse (C++/CLI und C++/CX)
Deklariert eine Enumeration im Namespacebereich, die ein benutzerdefinierter Typ ist, der aus einem Satz von benannten Konstanten besteht, die als Enumeratoren bezeichnet werden.
Alle Laufzeiten
Hinweise
C++/CX und C++/CLI unterstützen öffentliche Enumerationsklassen und private Enumerationsklassen, die der standardmäßigen Enumerationsklasse von C++ ähneln, jedoch zusätzlich einen Zugriffsspezifizierer besitzen. Unter /clrist der C++11-Typ enum class zulässig, jedoch wird die Warnung C4472 generiert, die sicherstellen soll, dass Sie tatsächlich den ISO-Enumerationstyp und nicht den C++/CX- und C++/CLI-Typ verwenden möchten. Weitere Informationen zum ISO-Standard-C++ enum -Schlüsselwort finden Sie unter Enumerationen.
Windows-Runtime
Syntax
access
enum class
enumeration-identifier
[:underlying-type] { enumerator-list } [var];
accessenum structenumeration-identifier[:underlying-type] { enumerator-list } [var];
Parameter
access
Der Zugriff auf die Enumeration, die public oder privatesein kann.
enumeration-identifier
Der Name der Enumeration.
underlying-type
(Optional) Der zugrunde liegende Typ der Enumeration.
(Optional. nur Windows-Runtime) Der zugrunde liegende Typ der Aufzählung, die kann bool, , char, char16, int16, uint16, int, , uint32, , , oder int64uint64.
enumerator-list
Eine durch Komma getrennte Liste mit Enumeratornamen.
Der Wert jedes Enumerators ist ein konstanter Ausdruck, der entweder implizit vom Compiler oder explizit durch die Notation enumerator=constant-expression. Standardmäßig ist der Wert des ersten Enumerators Null, wenn er implizit definiert ist. Der Wert jedes folgenden implizit definierten Enumerators ist der Wert des vorherigen Enumerators + 1.
var
(Optional) Der Name einer Variablen des Enumerationstyps.
Hinweise
Weitere Informationen und Beispiele finden Sie unter Enums.
Beachten Sie, dass der Compiler Fehlermeldungen ausgibt, wenn der konstante Ausdruck, der den Wert eines Enumerators definiert, nicht durch den underlying-typedargestellt werden kann. Der Compiler meldet jedoch keinen Fehler für einen Wert, der für den zugrunde liegenden Typ ungeeignet ist. Zum Beispiel:
Wenn der zugrunde liegende Typ numerisch ist und ein Enumerator den Maximalwert für diesen Typ angibt, kann der Wert der nächsten implizit definierten Aufzählung nicht dargestellt werden.
Wenn der underlying-type
boolist und mehr als zwei Enumeratoren implizit definiert werden, können die Enumeratoren, die auf die ersten beiden folgen, nicht dargestellt werden.Wenn der underlying-type
char16ist und der Enumerationswert von 0xD800 bis 0xDFFF reicht, kann der Wert dargestellt werden. Der Wert ist jedoch logisch falsch, da er die Hälfte ein Unicode-Ersatzzeichenpaars darstellt und nicht isoliert angezeigt werden soll.
Anforderungen
Compileroption: /ZW
Übersicht: Common Language Runtime (CLR)
Syntax
access
enum class
name [:type] { enumerator-list } var;
accessenum structname [:type] { enumerator-list } var;
Parameter
access
Die Zugriff der Enumeration. Kann entweder public oder private sein.
enumerator-list
Eine durch Komma getrennte Liste der Bezeichner (Enumeratoren) in der Enumeration.
name
Der Name der Enumeration. Anonyme verwaltete Enumerationen sind nicht zulässig.
type
(Optional) Der zugrunde liegende Typ der Bezeichner. Dies kann ein beliebiger Skalartyp sein, z. B. signierte oder nicht signierte Versionen von int, oder shortlong. bool oder char ist ebenfalls zulässig.
var
(Optional) Der Name einer Variablen des Enumerationstyps.
Hinweise
enum class und enum struct sind entsprechende Deklarationen.
Es gibt zwei Typen von Enumerationen: C++/CX und Standard.
Eine verwaltete oder C++/CX-Enumeration kann wie folgt definiert sein:
public enum class day {sun, mon };
und ist semantisch äquivalent zu:
ref class day {
public:
static const int sun = 0;
static const int mon = 1;
};
Eine Standard-Enumeration kann wie folgt definiert sein:
enum day2 { sun, mon };
und ist semantisch äquivalent zu:
static const int sun = 0;
static const int mon = 1;
Verwaltete Enumeratornamen (Bezeichner) werden nicht in den Bereich injiziert, in dem die Enumeration definiert ist. Alle Verweise auf Enumeratoren müssen vollständig qualifiziert sein (Name::Bezeichner). Aus diesem Grund können Sie keine anonyme verwaltete Enumeration definieren.
Die Enumeratoren einer Standardenumeration werden stark in den einschließenden Bereich eingefügt. Das heißt, wenn es ein anderes Symbol mit dem gleichen Namen wie ein Enumerator im einschließenden Bereich gibt, generiert der Compiler einen Fehler.
In Visual Studio 2002 und Visual Studio 2003 wurden Enumeratoren schwach eingefügt (sichtbar im einschließenden Bereich, sofern es keinen anderen Bezeichner mit demselben Namen gibt).
Wenn eine C++-Standardenume definiert ist (ohne class oder struct), führt die Kompilierung dazu /clr , dass die Enumeration als verwaltete Enumeration kompiliert wird. Die Enumeration hat weiterhin die Semantik einer nicht verwalteten Enumeration. Hinweis: Der Compiler fügt das Attribut Microsoft::VisualC::NativeEnumAttribute ein, um zu kennzeichnen, dass der Programmierer eine native Enumeration beabsichtigt hat. Andere Compiler erkennen einfach die Standardenumeration als verwaltete Enumeration.
Eine benannte Standardenumeration, die mit /clr kompiliert wurde, ist in der Assembly als verwaltete Enumeration sichtbar und kann von jedem anderen verwalteten Compiler genutzt werden. Eine unbenannte Standardenumeration ist jedoch nicht öffentlich aus der Assembly sichtbar.
In Visual Studio 2002 und Visual Studio 2003 würde eine Standardenumeration, die als Typ in einem Funktionsparameter verwendet wird:
// mcppv2_enum.cpp
// compile with: /clr
enum E { a, b };
void f(E) {System::Console::WriteLine("hi");}
int main() {
E myi = b;
f(myi);
}
die folgende in MSIL für die Funktionssignatur ausgeben:
void f(int32);
In den aktuellen Versionen des Compilers, wird die Standardenumeration als verwaltete Enumeration mit einem [NativeEnumAttribute] und dem folgenden in MSIL für die Funktionssignatur ausgegeben:
void f(E)
Weitere Informationen zu systemeigenen Enumerationen finden Sie unter Deklarationen von C++-Enumerationen.
Weitere Informationen zu CLR-Enumerationen finden Sie unter:
Anforderungen
Compileroption: /clr
Beispiele
// mcppv2_enum_2.cpp
// compile with: /clr
// managed enum
public enum class m { a, b };
// standard enum
public enum n { c, d };
// unnamed, standard enum
public enum { e, f } o;
int main()
{
// consume managed enum
m mym = m::b;
System::Console::WriteLine("no automatic conversion to int: {0}", mym);
System::Console::WriteLine("convert to int: {0}", (int)mym);
// consume standard enum
n myn = d;
System::Console::WriteLine(myn);
// consume standard, unnamed enum
o = f;
System::Console::WriteLine(o);
}
no automatic conversion to int: b
convert to int: 1
1
1