Declarações de enumeração de C++
Uma enumeração é um tipo definido pelo usuário que consiste em um conjunto de constantes nomeadas chamados enumeradores.
Para obter informações sobre enums CLR, consulte classe enum.
enum [tag] [: type] {enum-list} [declarator]; // for definition of enumerated type
enum tag declarator; // for declaration of variable of type tag
Parâmetros
tag
O nome de tipo dado à enumeração.type
O tipo subjacente dos identificadores de enumeração.Consulte Comentários.enum-list
Lista os enumeradores contidos pela enumeração.declarator
Lista de Declarador que especifica os nomes da enumeração.Para obter mais informações, consulte Visão geral de declaradores.
Comentários
Uma enumeração fornece contexto para descrever um intervalo de valores.O exemplo a seguir mostra uma enumeração que contém quatro naipes em um baralho de cartas.
enum Suit { Diamonds, Hearts, Clubs, Spades };
Cada nome da enumeração se torna um enumerador e é atribuído um valor que corresponde ao seu lugar na ordem de valores na enumeração.Por padrão, o primeiro valor é atribuído a 0, a próxima é atribuído 1 e assim por diante.Você pode definir o valor de um enumerador.
enum Suit { Diamonds = 1,
Hearts,
Clubs,
Spades };
O enumerador Diamonds recebe o valor 1.Isso afeta os valores que são atribuídos a enumeradores subseqüentes; Heartsé atribuído o valor 2, Clubs 3 e assim por diante.
Em C, o enum palavra-chave é necessária para declarar uma enumeração.No C++, o enum palavra-chave pode ser omitido.Por exemplo:
Suit current; // Legal in C++ only
Valores específicos pode ser atribuída a uma variável com base em uma enumeração.
Suit currentSuit = Hearts;
Se você tentar atribuir hand um valor que não seja um dia da semana,
int myAccountNumber = 012345678;
Suit hand;
hand = myAccountNumber;
o compilador sinalizadores esta atribuição como um erro em tempo de compilação.Embora tecnicamente ambas as variáveis são números inteiros, a projeção é necessário para converter um int em uma enumeração.No entanto, você pode fazer o inverso e promover um enumerador para um valor inteiro sem uma conversão.
myAccountNumber = hearts;
typeé o tipo subjacente da identificadores de.Isso pode ser qualquer tipo de escalar, como sinal ou versões do int, short, ou long.boolou char também é permitido.
Os tipos enumerados são valiosos quando um objeto pode assumir um conjunto conhecido e razoavelmente limitado de valores.Considere o exemplo dos naipes de um baralho de cartas:
// 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;
}
O exemplo anterior define uma classe, Card, que contém um tipo enumerado aninhado, Suit.
Porque o tipo de Suit estiver aninhado, o nome da classe (Card) deve ser usado explicitamente em referências públicas.Nos métodos, o nome da classe pode ser omitido.
O operador de incremento de sufixo para Card::Suit é definido porque sem um operador de incremento definida pelo usuário, curSuit não pode ser incrementado.Para obter mais informações sobre operadores definidos pelo usuário, consulte Sobrecarga de operador.
O código a seguir cria um pacote de cartões.
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 );
Considere o exemplo a seguir em relação ao NameOf método.
#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;
}
Um tipo enumerado é um tipo integral.Os identificadores introduzido com o enum declaração pode ser usada onde quer que as constantes aparecem.Normalmente, o valor do identificador do primeiro for 0 (Diamonds, no exemplo anterior), e os valores aumentarem em um para cada identificador subseqüente.Portanto, o valor de Spades é 3.
Enumeradores não precisam ter valores exclusivos em uma enumeração.O nome de cada enumerador é tratado como uma constante e deve ser exclusivo dentro do escopo em que o enum está definido.
Qualquer enumerador na lista, incluindo a primeira, pode ser inicializado com um valor diferente de seu valor padrão.Suponha que a declaração do Suit tivesse sido o seguinte:
enum Suit {
Diamonds = 5,
Hearts,
Clubs = 4,
Spades
};
Em seguida, os valores de Diamonds, Hearts, Clubs, e Spades teria sido 5, 6, 4 e 5, respectivamente.Observe que o 5 é usado mais de uma vez.
Os valores padrão para esses enumeradores simplificam a implementação de NameOf função:
#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;
}
A função de assessor GetSuit retorna o tipo de Suit, um tipo enumerado.Como os tipos enumerados são tipos integrais, pode ser usados como argumentos para o operador de subscrito de matriz.(Para obter mais informações, consulte Subscrito operador.)