Dieser Artikel wurde maschinell übersetzt. Wenn Sie die englische Version des Artikels anzeigen möchten, aktivieren Sie das Kontrollkästchen Englisch. Sie können den englischen Text auch in einem Popupfenster anzeigen, indem Sie den Mauszeiger über den Text bewegen.
Übersetzung
Englisch

enum class (Komponentenerweiterungen für C++)

Deklariert eine Enumeration. Dies ist ein benutzerdefinierter Typ, der aus einem Satz von benannten Konstanten besteht, die als Enumeratoren bezeichnet werden.

Hinweise

C++/CX und C++/CLI unterstützen public enum class und private enum class, die der standardmäßigen C++-Enumerationsklasse ähneln, jedoch einen Zugriffsspezifizierer haben. Weitere Informationen zum C++-Schlüsselwort nach altem Standard (enum) finden Sie unter C++-Enumerations-Deklarationen.

Syntax

access enum class enumeration-identifier [:underlying-type] { enumerator-list } [var];
access enum struct enumeration-identifier [:underlying-type] { enumerator-list } [var];

Parameter

access

Der Zugriff auf die Enumeration, die public oder private sein kann.

Enumerationsbezeichner

Der Name der Enumeration.

Zugrunde liegender Typ

(Optional) Der zugrunde liegende Typ der Enumeration.

(Optional. Nur Windows-Runtime) Der zugrunde liegende Enumerationstyp, der bool, char, char16, int16, uint16, int, uint32, int64 oder uint64 sein kann.

Enumeratorliste

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=konstanter Ausdruck definiert wird. 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 Enumeratoren.

Beachten Sie, dass der Compiler Fehlermeldungen ausgibt, wenn der konstante Ausdruck, der den Wert eines Enumerators definiert, nicht durch den zugrunde liegenden Typ dargestellt 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 maximalen Wert für diesen Typ angibt, kann der Wert der folgenden implizit definierten Enumeration nicht dargestellt werden.

  • Wenn der zugrunde liegende Typbool ist und mehr als zwei Enumeratoren implizit definiert werden, können die Enumeratoren, die auf die ersten beiden folgen, nicht dargestellt werden.

  • Wenn der zugrunde liegende Typchar16 ist 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.

a6cskb49.collapse_all(de-de,VS.110).gifAnforderungen

Compileroption: /ZW

Syntax

access enum class name [:type] { enumerator-list } var;
access enum struct name [:type] { enumerator-list } var;

Parameter

access

Die Zugriff der Enumeration. Er kann entweder öffentlich 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. Dabei kann es sich um einen beliebigen skalaren Typ handeln, wie Versionen mit oder ohne Vorzeichen von int, short oder long. bool oder char sind 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: Verwaltete und Standard.

Eine verwaltete Enumeration kann wie folgt definiert sein:

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 eingefügt, 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 C++ 2002 und Visual C++ 2003 wurden Enumeratoren schwach eingefügt (sichtbar im einschließenden Bereich, es sei denn, es gibt einen anderen Bezeichner mit demselben Namen).

Wenn eine standardmäßige C++-Enumeration (ohne class oder struct) definiert ist, wird die Enumeration beim Kompilieren mit /clr als verwaltete Enumeration kompiliert. Die Enumeration hat weiterhin die Semantik einer nicht verwalteten Enumeration. Hinweis: Der Compiler fügt ein Attribut (Microsoft::VisualC::NativeEnumAttribute) ein, das der Visual C++-Compiler erkennt. So wird gekennzeichnet, dass der Programmierer möchte, dass die Enumeration eine systemeigene Enumeration ist. 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 einem anderen verwalteten Compiler genutzt werden. Eine unbenannte Standardenumeration ist jedoch nicht öffentlich aus der Assembly sichtbar.

In Visual C++ 2002 und Visual C++ 2003 würde eine Standardenumeration, die als Typ in einem Funktionsparameter verwendet wird, wie folgt aussehen:

// 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.

In der Entwicklungsumgebung können Sie F1-Hilfe für diese Schlüsselwörtern abrufen, indem Sie das Schlüsselwort (z. B. enum class) markieren und F1 drücken.

Weitere Informationen zu CLR-Enumerationen finden Sie unter:

a6cskb49.collapse_all(de-de,VS.110).gifAnforderungen

Compileroption: /clr

a6cskb49.collapse_all(de-de,VS.110).gifBeispiele

Beispiel

desc

// 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);
}Optionally, copy this sequence of tags for each example you want, then populate the text nodes. That is, after section+title("Examples")+content, insert: para+embeddedLabel ("Example")+para(sample description); code(sample); para+embeddedLabel("Output"); computerOutput(sample output, including 'br' tag instead of newlines)

Ausgabe

keine automatische Konvertierung zu int: b
konvertieren zu int: 1
1
1

Community-Beiträge

HINZUFÜGEN
Anzeigen: