Declaraciones de enumeración de C++
Una enumeración es un tipo definido por el usuario que está compuesto de un conjunto de constantes con nombre denominadas los enumeradores.
Para obtener información sobre las enumeraciones de CLR, vea clase de enumeración.
enum [tag] [: type] {enum-list} [declarator]; // for definition of enumerated type
enum tag declarator; // for declaration of variable of type tag
Parámetros
tag
El nombre de tipo especificado a la enumeración.type
El tipo de los identificadores de la enumeración.Vea la sección Comentarios.enum-list
Lista de los enumeradores contiene la enumeración.declarator
El declarador muestra que especifica los nombres de la enumeración.Para obtener más información, vea Información general de Declarators.
Comentarios
una enumeración proporciona contexto para describir un intervalo de valores.El ejemplo siguiente se muestra una enumeración que contiene los cuatro adapte en una superposición de cartas.
enum Suit { Diamonds, Hearts, Clubs, Spades };
Cada nombre de enumeración se convierte en un enumerador y se asigna un valor que corresponde al lugar en el orden de los valores de la enumeración.de forma predeterminada, el primer valor se asigna 0, el siguiente se asigna 1, y así sucesivamente.Puede establecer el valor de un enumerador.
enum Suit { Diamonds = 1,
Hearts,
Clubs,
Spades };
asignan el enumerador Diamonds el valor 1.Esto afecta a los valores asignados a los enumeradores subsiguientes; Hearts se asigna el valor 2, Clubs es 3, y así sucesivamente.
En C, la palabra clave de enum es necesario declarar una enumeración.En C++, la palabra clave de enum puede omitir.Por ejemplo:
Suit current; // Legal in C++ only
Una variable basada en una enumeración se pueden asignar valores concretos.
Suit currentSuit = Hearts;
Si intenta asignar hand un valor que no es un día de la semana,
int myAccountNumber = 012345678;
Suit hand;
hand = myAccountNumber;
el compilador marca esta asignación como un error en tiempo de compilación.Aunque ambas variables son técnico números enteros, una conversión es necesario convertir int a una enumeración.Sin embargo, puede ir a otra forma y promover un enumerador a un valor entero sin una conversión.
myAccountNumber = hearts;
type es el tipo de los identificadores.Puede tratarse de tipo escalar, como versiones con signo o sin signo de int, de short, o de long.bool o char también se permite.
Los tipos de lista tienen valores cuando un objeto puede suponer un conjunto conocido y razonablemente limitado de valores.Considere el ejemplo de los adapte de una superposición 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;
}
El ejemplo anterior define una clase, Card, que contiene un tipo enumerado anidadas, Suit.
Porque anidados al tipo Suit , el nombre de clase (Card) se debe utilizar explícitamente en referencias públicas.En métodos, el nombre de clase se puede omitir.
El operador de incremento del sufijo para Card::Suit se define como sin un operador definido por el usuario de incremento, curSuit no puede incrementar.Para obtener más información sobre los operadores definidos por el usuario, vea Sobrecarga de operadores.
El código siguiente crea un paquete de cartas.
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 el ejemplo siguiente con el método de 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 tipo enumerado es un tipo entero.Los identificadores proporcionados con la declaración de enum pueden utilizar dondequiera que aparezcan las constantes.Normalmente, el valor del primer identificador es 0 (Diamonds, en el ejemplo anterior), y los valores aumentan por uno para cada identificador sucesivo.Por consiguiente, el valor de Spades es 3.
Los enumeradores no necesitan tener valores únicos de una enumeración.El nombre de cada enumerador se trata como constante y debe ser único dentro del ámbito que se define enum .
Cualquier enumerador en la lista, como primera, puede inicializar en un valor distinto del valor predeterminado.Suponga que la declaración de Suit se hubiera los siguientes:
enum Suit {
Diamonds = 5,
Hearts,
Clubs = 4,
Spades
};
A continuación los valores de Diamonds, de Hearts, de Clubs, y de Spades pudieran estar 5, 6, 4, y 5, respectivamente.Observe que 5 se utiliza más de una vez.
los valores predeterminados para estos enumeradores simplifican la implementación de la función de 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;
}
La función GetSuit de descriptor de acceso devuelve el tipo Suit, tipo enumerado.Dado que los tipos enumerados son tipos enteros, se pueden utilizar como argumentos el operador de subíndice de la matriz.(Para obtener más información, vea Operador de subíndice.)
Vea también
Referencia
Declaraciones de enumeración de C