Declaraciones de enumeración de C

Una enumeración consta de un conjunto de constantes de enteros con nombre. Una declaración de tipo de enumeración proporciona el nombre de la etiqueta de enumeración (opcional). Además, define el conjunto de identificadores enteros con nombre (denominado conjunto de enumeración, constantes de enumerador, enumeradores o miembros). Una variable del tipo de enumeración almacena uno de los valores del conjunto de enumeraciones definido por ese tipo.

Las variables de enum tipo se pueden usar en expresiones de indexación y como operandos de todos los operadores aritméticos y relacionales. Las enumeraciones proporcionan una alternativa a la #define directiva de preprocesador con las ventajas que se pueden generar para usted y obedecer las reglas de ámbito normales.

En ANSI C, las expresiones que definen el valor de una constante de enumerador siempre tienen int tipo. Esto significa que el almacenamiento asociado a una variable de enumeración es el almacenamiento necesario para un valor único int . Se puede usar una constante de enumeración o un valor de tipo enumerado en cualquier lugar en el que el lenguaje C permita una expresión entera.

Sintaxis

enum-specifier:
  enum identifier _optar{enumerator-list}
  enum identifier

enumerator-list:
 enumerator
  enumerator-list , enumerator

enumerator:
 enumeration-constant
  enumeration-constant = constant-expression

enumeration-constant:
 identifier

El nombre opcional identifier asigna al tipo de enumeración definido por enumerator-list. Este identificador suele denominar "etiqueta" de la enumeración especificada por la lista. Un especificador de tipo declara identifier que es la etiqueta de la enumeración especificada por el enumerator-list noterminal, como se muestra aquí:

enum identifier
{
    // enumerator-list
}

enumerator-list define los miembros del conjunto de enumeraciones.

Si la declaración de una etiqueta es visible, las declaraciones posteriores que usan la etiqueta pero omiten enumerator-list especifican el tipo enumerado declarado anteriormente. La etiqueta debe hacer referencia a un tipo de enumeración definido y ese tipo de enumeración debe estar en el ámbito actual. Dado que el tipo de enumeración se define en otra parte, no enumerator-list aparece en esta declaración. Las declaraciones de tipos derivados de enumeraciones y typedef declaraciones para los tipos de enumeración pueden usar la etiqueta de enumeración antes de definir el tipo de enumeración.

Cada enumeration-constant uno de los enumerator-list nombres de un valor del conjunto de enumeraciones. De forma predeterminada, el primero enumeration-constant está asociado al valor 0. La siguiente enumeration-constant de la lista está asociada al valor de ( constant-expression + 1 ), a menos que la asocie explícitamente a otro valor. El nombre de es enumeration-constant equivalente a su valor.

Puede usar enumeration-constant = constant-expression para invalidar la secuencia predeterminada de valores. Es decir, si enumeration-constant = constant-expression aparece en enumerator-list, el enumeration-constant objeto está asociado al valor proporcionado por constant-expression. constant-expression debe tener int el tipo y puede ser negativo.

Las reglas siguientes se aplican a los miembros de un conjunto de enumeraciones:

• Un conjunto de enumeraciones puede contener valores constantes duplicados. Por ejemplo, podría asociar el valor 0 con dos identificadores diferentes, por ejemplo, miembros denominados null y zero, en el mismo conjunto.

• Los identificadores de la lista de enumeraciones deben ser distintos de otros identificadores del mismo ámbito con la misma visibilidad. Esto incluye nombres y identificadores de variables normales en otras listas de enumeración.

• Las etiquetas de enumeración cumplen las reglas de ámbito normales. Deben ser distintos de otras etiquetas de enumeración, estructura y unión con la misma visibilidad.

Ejemplos

En estos ejemplos se muestran las declaraciones de enumeración:

enum DAY            /* Defines an enumeration type    */
{
    saturday,       /* Names day and declares a       */
    sunday = 0,     /* variable named workday with    */
    monday,         /* that type                      */
    tuesday,
    wednesday,      /* wednesday is associated with 3 */
    thursday,
    friday
} workday;

El valor 0 está asociado de saturday forma predeterminada. El identificador sunday se establece explícitamente en 0. Los identificadores restantes reciben los valores de 1 a 5 de forma predeterminada.

En este ejemplo, se asigna un valor del conjunto DAY a la variable today.

enum DAY today = wednesday;

El nombre de la constante de enumeración se usa para asignar el valor. Puesto que el DAY tipo de enumeración se declaró anteriormente, solo es necesaria la etiqueta DAY de enumeración.

Para asignar explícitamente un valor entero a una variable de un tipo de datos enumerado, use una conversión de tipos:

workday = ( enum DAY ) ( day_value - 1 );

Esta conversión se recomienda en C, pero no es necesaria.

enum BOOLEAN  /* Declares an enumeration data type called BOOLEAN */
{
    false,     /* false = 0, true = 1 */
    true
};

enum BOOLEAN end_flag, match_flag; /* Two variables of type BOOLEAN */

Esta declaración también se puede especificar como

enum BOOLEAN { false, true } end_flag, match_flag;

o como

enum BOOLEAN { false, true } end_flag;
enum BOOLEAN match_flag;

Un ejemplo que use estas variables podría tener este aspecto:

if ( match_flag == false )
    {
     .
     .   /* statement */
     .
    }
    end_flag = true;

También se pueden declarar tipos de datos de enumerador sin nombre. Se omite el nombre del tipo de datos, pero se pueden declarar variables. La variable response es una variable del tipo definido:

enum { yes, no } response;

Consulte también

Enumeraciones(C++)