Dichiarazioni di enumerazione C++
Un'enumerazione è un tipo definito dall'utente costituita da un insieme di costanti denominate chiamate enumeratori.
Per informazioni sulle enumerazioni CLR, vedere classe enum.
enum [tag] [: type] {enum-list} [declarator]; // for definition of enumerated type
enum tag declarator; // for declaration of variable of type tag
Parametri
tag
Il nome del tipo fornito all'enumerazione.type
Il tipo sottostante degli identificatori di enumerazione.Vedere la sezione Osservazioni.enum-list
Elenco di enumeratori contenuto dell'enumerazione.declarator
Elenco dei dichiaratori che specifica i nomi dell'enumerazione.Per ulteriori informazioni, vedere Cenni preliminari sui dichiaratori.
Note
Un'enumerazione fornisce contesto per descrivere un intervallo di valori.Nell'esempio seguente viene illustrato un'enumerazione che contiene i quattro soddisfi in un deck delle schede.
enum Suit { Diamonds, Hearts, Clubs, Spades };
Ogni nome dell'enumerazione diventa un enumeratore e viene assegnato un valore corrispondente al posto dei valori dell'enumerazione.Per impostazione predefinita, il primo valore viene assegnato 0, il successivo viene assegnato 1, e così via.È possibile impostare il valore di un enumeratore.
enum Suit { Diamonds = 1,
Hearts,
Clubs,
Spades };
l'enumeratore Diamonds viene assegnato il valore 1.Ciò influisce sui valori assegnati agli enumeratori successivi, Hearts viene assegnato il valore 2, Clubs sono 3, e così via.
In C#, enum la parola chiave è obbligatoria per dichiarare un'enumerazione.in C++, enum la parola chiave può essere omesso.Di seguito è riportato un esempio:
Suit current; // Legal in C++ only
Una variabile basata su un'enumerazione è possibile assegnare valori specifici.
Suit currentSuit = Hearts;
Se si tenta di assegnare hand un valore che non è un giorno della settimana,
int myAccountNumber = 012345678;
Suit hand;
hand = myAccountNumber;
il compilatore contrassegna questa assegnazione come errore in fase di compilazione.Anche se entrambe le variabili siano tecnicamente numeri interi, un cast è necessario convertire int un'enumerazione.Tuttavia, è possibile passare viceversa e perché un enumeratore a un valore Integer senza un cast.
myAccountNumber = hearts;
type è il tipo sottostante di identificatori.Ciò può essere qualsiasi tipo scalare, ad esempio versioni con segno o unsigned di int, short, o long.bool o char inoltre è consentito.
I tipi enumerati sono utili quando un oggetto può assumere noto e abbastanza set limitato di valori.Si consideri l'esempio di più di un deck delle schede:
// 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;
}
Nell'esempio precedente viene definita la classe, Card, che contiene un tipo enumerato annidato, Suit.
Poiché il tipo Suit è annidato, il nome della classe (Card) deve essere utilizzato in modo esplicito nei riferimenti pubblici.Nei metodi, il nome della classe può essere omesso.
L'operatore di decremento suffisso per Card::Suit viene definito in quanto senza un operatore di decremento definito dall'utente, curSuit non è possibile incrementare.Per ulteriori informazioni sugli operatori definiti dall'utente, vedere Overload degli operatori.
Il codice seguente viene creato un pacchetto delle schede.
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 );
Si consideri l'esempio relativo a NameOf metodo.
#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 tipo enumerato è un tipo integrale.gli identificatori introdotti con enum la dichiarazione può essere utilizzata ovunque le costanti inferiori.In genere, il valore del primo identificatore è 0 (Diamonds, nell'esempio precedente) e di valori aumentare di uno per ogni identificatore successivo.di conseguenza, il valore di Spades è 3.
Gli enumeratori non devono contenere valori univoci in un'enumerazione.Il nome di ogni enumeratore viene considerato come costante e deve essere univoco nell'ambito in cui enum è definito.
Un enumeratore nell'elenco, inclusi il primo, può essere inizializzato su un valore diverso dal valore predefinito.Si supponga la dichiarazione di Suit era stato quanto segue:
enum Suit {
Diamonds = 5,
Hearts,
Clubs = 4,
Spades
};
Quindi i valori di Diamonds, Hearts, Clubse Spades sarebbero 5, 6, 4 e 5, rispettivamente.Si noti che 5 vengono utilizzati più volte.
I valori predefiniti per gli enumeratori semplifica l'implementazione di NameOf funzione:
#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;
}
La funzione di accesso GetSuit tipo di restituisce Suit, un tipo enumerato.Poiché i tipi enumerati sono tipi integrali, possono essere utilizzati come argomenti all'operatore di indice di matrice.(Per ulteriori informazioni, vedere Operatore di indice).
Vedere anche
Riferimenti
Dichiarazioni di enumerazione c