C++-Enumerations-Deklarationen
Eine Enumeration ist ein benutzerdefinierter Typ, der aus einem Satz von benannten Konstanten besteht, die Enumeratoren aufgerufen werden.
Weitere Informationen zu CLR-Enumerationen finden Sie unter enum class.
enum [tag] [: type] {enum-list} [declarator]; // for definition of enumerated type
enum tag declarator; // for declaration of variable of type tag
Parameter
tag
Der Typname der angegebenen Enumeration.type
Der zugrunde liegende Typ der Enumeration bezeichner.Siehe Hinweise.enum-list
Liste der Enumeratoren in der Enumeration.declarator
Deklaratoren aufgelistet, die die Namen der Enumeration angibt.Weitere Informationen finden Sie unter Übersicht über Deklaratoren.
Hinweise
Eine Enumeration stellt Kontext, um einen Wertebereich zu beschreiben.Im folgenden Beispiel wird eine Enumeration an, die die vier Aktionen in einem Kartenstapel enthält.
enum Suit { Diamonds, Hearts, Clubs, Spades };
Jeder Name der Enumeration übermittelt und eines Enumerators wird ein Wert zugewiesen, der auf den Stelle in der Reihenfolge der Werte in der Enumeration entspricht.Standardmäßig wird der erste Wert 0, die nächste zugewiesen ist 1 usw. zugewiesen.Sie können den Wert eines Enumerators festlegen.
enum Suit { Diamonds = 1,
Hearts,
Clubs,
Spades };
Der Enumerator Diamonds wird der Wert 1zugewiesen.Dies betrifft die folgenden Werte zugewiesen sind die Enumeratoren. Hearts wird der Wert 2, Clubs ist 3 usw. zugewiesen.
In C ist das enum-Schlüsselwort erforderlich, um eine Enumeration zu deklarieren.In C++ kann das enum-Schlüsselwort weggelassen werden.Beispiele:
Suit current; // Legal in C++ only
Eine Variable auf Grundlage einer Enumeration kann bestimmte Werte zugewiesen werden.
Suit currentSuit = Hearts;
Wenn Sie versuchen, hand einen Wert zuzuweisen, der kein Wochentag ist.
int myAccountNumber = 012345678;
Suit hand;
hand = myAccountNumber;
Flags der Compiler diese Zuweisung zur Kompilierzeit als Fehler.Obwohl beide Variablen ganze Zahlen sind technisch gesehen, ist eine Umwandlung erforderlich, int-Enumerationen zu konvertieren.Wechseln Sie können jedoch die andere Methode und einen Enumerator für einen Ganzzahlwert ohne eine Umwandlung fördern.
myAccountNumber = hearts;
type ist der zugrunde liegende Typ der Bezeichner.Dabei kann es sich um ein skalarer Typ, wie Versionen mit oder ohne Vorzeichen aus int, shortoder longsein.bool oder char wird ebenfalls nicht zulässig.
Enumerationstypen wertvoll sind, wenn ein Objekt einen bekannten und angemessen eingeschränkten Gruppe von Werten annehmen kann.Betrachten Sie das Beispiel für die Aktionen ein Kartenstapel:
// enumeration_declarations.cpp
// compile with: /c
class Card {
public:
enum Suit {
Diamonds,
Hearts,
Clubs,
Spades
};
// Declare two constructors: a default constructor,
// and a constructor that sets the cardinal and
// suit value of the new card.
Card();
Card( int CardInit, Suit SuitInit );
// Get and Set functions.
int GetCardinal(); // Get cardinal value of card.
int SetCardinal(); // Set cardinal value of card.
Suit GetSuit(); // Get suit of card.
void SetSuit(Suit new_suit); // Set suit of card.
char *NameOf(); // Get string representation of card.
private:
Suit suit;
int cardinalValue;
};
// Define a postfix increment operator for Suit.
inline Card::Suit operator++( Card::Suit &rs, int ) {
Card::Suit oldSuit = rs;
rs = (Card::Suit)(rs + 1);
return oldSuit;
}
Im vorhergehenden Beispiel wird eine Klasse Card, die einen geschachtelten Enumerationstyp enthält, Suit.
Da der Typ Suit geschachtelt ist, muss der Klassenname (Card) verwendete Verweise explizit öffentlich sein.In den Methoden der Klassenname kann ausgelassen werden.
Der Operator für Postfixinkrements Card::Suit wird definiert, da ohne einen benutzerdefinierten Inkrementoperator, curSuit nicht erhöht werden kann.Weitere Informationen zu benutzerdefinierten Operatoren finden Sie unter Überladen von Operatoren.
Im folgenden Code wird ein Kartenspiel.
Card *Deck[52];
int j = 0;
for( Card::Suit curSuit = Card::Diamonds ; curSuit <= Card::Spades ; curSuit++ )
for( int i = 1; i <= 13; ++i )
Deck[j++] = new Card( i, curSuit );
Betrachten Sie das folgende Beispiel in Bezug auf die NameOf-Methode.
#define SIZE_OF_CARD_NAMES 20
char* Card::NameOf() { // Get the name of a card.
static char szName[SIZE_OF_CARD_NAMES];
static char *Numbers[] = {
"1", "2", "3", "4", "5", "6", "7", "8", "9",
"10", "Jack", "Queen", "King"
};
static char *Suits[] = {
"Diamonds", "Hearts", "Clubs", "Spades"
};
if( GetCardinal() < 13)
strcpy_s( szName, SIZE_OF_CARD_NAMES, Numbers[GetCardinal()] );
strcat_s( szName, SIZE_OF_CARD_NAMES, " of " );
switch( GetSuit() ) {
// Diamonds, Hearts, Clubs, and Spades do not need explicit
// class qualifier.
case Diamonds:
strcat_s( szName, SIZE_OF_CARD_NAMES , "Diamonds" );
break;
case Hearts:
strcat_s( szName, SIZE_OF_CARD_NAMES , "Hearts" );
break;
case Clubs:
strcat_s( szName, SIZE_OF_CARD_NAMES , "Clubs" );
break;
case Spades:
strcat_s( szName, SIZE_OF_CARD_NAMES , "Spades" );
break;
}
return szName;
}
Ein Aufzählungstyp ist ein ganzzahliger Typ.Die ID, die der enum Deklaration eingegeben werden, können verwendet werden, bei denen Konstanten angezeigt werden.Normalerweise handelt es sich um den ersten Wert des Bezeichners 0 (Diamonds, im vorhergehenden Beispiel), und die Werte akzeptieren um einen für jeden folgenden Bezeichner zu.Deshalb ist der Wert von Spades 3.
Enumeratoren müssen nicht eindeutige Werte in einer Enumeration angewendet wurden.Der Name eines Enumerators wird als Konstante behandelt und muss innerhalb des Gültigkeitsbereichs eindeutig sein, in dem enum definiert ist.
Jeder Enumerator in der Liste, einschließlich der erste auch auf einen anderen Wert als den Standardwert initialisiert werden.Angenommen, die Deklaration von Suit wurden die folgenden:
enum Suit {
Diamonds = 5,
Hearts,
Clubs = 4,
Spades
};
Anschließend werden die Werte von Diamonds, Hearts, Clubsund Spades 5, 6, 4 bzw. 5 erzeugt worden sein.Beachten Sie, dass 5 mehrmals verwendet wird.
Die Standardwerte für diese Enumeratoren vereinfachen die Implementierung der NameOf-Funktion:
#define SIZE_OF_CARD_NAMES 20
char* Card::NameOf() { // Get the name of a card.
static char szName[SIZE_OF_CARD_NAMES];
static char *Numbers[] = {
"1", "2", "3", "4", "5", "6", "7", "8", "9",
"10", "Jack", "Queen", "King"
};
static char *Suits[] = {
"Diamonds", "Hearts", "Clubs", "Spades"
};
if( GetCardinal() < 13)
strcpy_s( szName, SIZE_OF_CARD_NAMES, Numbers[GetCardinal()] );
strcat_s( szName, SIZE_OF_CARD_NAMES, " of " );
strcat_s( szName, SIZE_OF_CARD_NAMES, Suits[GetSuit()] );
return szName;
}
Die Accessorfunktion GetSuitSuitTyp gibt ein Enumerationstyp zurück.Da Enumerationstypen Ganzzahltypen sind, können sie als Argumente für den Operator Arrayfeldindex verwendet werden.(Weitere Informationen finden Sie unter Operator Tiefgestellter).