Déclarations d'énumération C++
Une énumération est un type défini par l'utilisateur qui se compose d'un jeu de constantes nommées appelées des énumérateurs.
Pour plus d'informations sur les enums CLR, consultez l' classe d'enum.
enum [tag] [: type] {enum-list} [declarator]; // for definition of enumerated type
enum tag declarator; // for declaration of variable of type tag
Paramètres
tag
le nom de type donné à l'énumération.type
le type sous-jacent des identificateurs d'énumération.Consultez la section Notes.enum-list
liste des énumérateurs contenus par l'énumération.declarator
Liste des déclarateurs qui spécifie les noms de l'énumération.Pour plus d'informations, consultez Vue d'ensemble des déclarateurs.
Notes
Une énumération fournit le contexte pour décrire une plage de valeurs.L'exemple suivant montre une énumération qui contient les quatre adaptée à dans un paquet de cartes.
enum Suit { Diamonds, Hearts, Clubs, Spades };
Chaque nom de l'énumération devient un énumérateur et est assigné une valeur qui correspond à sa place dans l'ordre des valeurs de l'énumération.par défaut, la première valeur est assignée 0, la suivante est assignée 1, et ainsi de suite.vous pouvez définir la valeur d'un énumérateur.
enum Suit { Diamonds = 1,
Hearts,
Clubs,
Spades };
l'énumérateur Diamonds est assigné la valeur 1.Cela affecte les valeurs assignées aux énumérateurs suivants ; Hearts est assigné la valeur 2, Clubs est 3, et ainsi de suite.
En C, le mot clé d' enum est requis pour déclarer une énumération.En C++, le mot clé d' enum peut être ignoré.Par exemple :
Suit current; // Legal in C++ only
Une variable basée sur une énumération ne pouvez assigner des valeurs spécifiques.
Suit currentSuit = Hearts;
si vous essayez d'assigner à hand une valeur qui n'est pas un jour de la semaine,
int myAccountNumber = 012345678;
Suit hand;
hand = myAccountNumber;
le compilateur signale cette assignation comme une erreur au moment de la compilation.Bien que techniquement les deux variables à des nombres entiers, un cast est requis pour convertir int à une énumération.Toutefois, vous pouvez passer l'autre méthode et promouvoir un énumérateur pour une valeur entière sans cast.
myAccountNumber = hearts;
type est le type sous-jacent des identificateurs.Cela peut être tout type scalaire, tel que les versions signés ou non signés d' int, d' short, ou d' long.il permet égalementbool ou char .
Les types énumérés sont valeur lorsqu'un objet peut prendre un ensemble et relativement limité de valeurs.Prenons l'exemple les adapté aux d'un paquet de cartes :
// 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;
}
l'exemple précédent définit une classe, Card, qui contient un type énuméré imbriqué, Suit.
Étant donné que le type Suit est imbriqué, le nom de classe (Card) doit être utilisé explicitement dans les références publiques.Dans les méthodes, le nom de classe peut être ignoré.
L'opérateur de post-incrémentation pour Card::Suit a la valeur car sans opérateur d'incrémentation défini par l'utilisateur, curSuit ne peut pas être incrémenté.Pour plus d'informations sur les opérateurs postfixés définis par l'utilisateur, consultez l' Surcharge d'opérateur.
Le code suivant crée un paquet de cartes.
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 );
Prenons l'exemple suivant en ce qui concerne la méthode d' NameOf .
#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;
}
un type énuméré est un type intégral.Les identificateurs présentés par la déclaration d' enum peuvent être utilisées partout où les constantes apparaissent.Normalement, du premier la valeur identificateur est 0 (Diamonds, dans l'exemple précédent), et les valeurs augmentent d'une pour chaque identificateur successif.par conséquent, la valeur d' Spades est 3.
les énumérateurs n'ont pas besoin d'avoir des valeurs uniques dans une énumération.Le nom de chaque énumérateur est traité comme une constante et doit être unique dans la portée où enum est défini.
Tout énumérateur dans la liste, y compris le premier, peut être initialisé avec une valeur autre que sa valeur par défaut.supposez que la déclaration d' Suit avait été la suivante :
enum Suit {
Diamonds = 5,
Hearts,
Clubs = 4,
Spades
};
puis les valeurs d' Diamonds, d' Hearts, d' Clubs, et d' Spades auraient été 5, 6, 4, et 5, respectivement.Notez que 5 est utilisé plusieurs fois.
les valeurs par défaut pour ces énumérateurs simplifient l'implémentation de la fonction d' NameOf :
#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;
}
Le retour d' GetSuit de fonction accesseur tapez Suit, un type énuméré.Étant donné que les types énumérés sont des types intégraux, ils peuvent être utilisés comme arguments de l'opérateur d'indice de tableau.(Pour plus d'informations, consultez l' opérateur souscrit.)