Compartilhar via


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

Consulte também

Referência

C declarações de enumeração

Palavras-chave C++

Nomes de enumerador

Definição de enumerador constantes

Conversões e tipos enumerados