Enumerations

Un tipo enumerado es un tipo distinto cuyo valor es un valor de su tipo subyacente (ver más abajo), que incluye los valores de constantes nombradas explícitamente ( constantes de enumeración ).

Sintaxis

El tipo enumerado se declara utilizando el siguiente especificador de enumeración como el type-specifier en la gramática de declaración :

donde enumerator-list es una lista separada por comas (se permite coma final) (desde C99) de enumerator , cada uno de los cuales tiene la forma:

donde

Al igual que con struct o union , una declaración que introduce un tipo enumerado y una o más constantes de enumeración también puede declarar uno o más objetos de ese tipo o de un tipo derivado del mismo.

enum color { RED, GREEN, BLUE } c = RED, *cp = &c;
// introduce el tipo enum color
// las constantes enteras RED, GREEN, BLUE
// el objeto c de tipo enum color
// el objeto cp de tipo puntero a enum color

Explicación

Cada constante-de-enumeración que aparece en el cuerpo de un especificador de enumeración se convierte en una constante entera con tipo int (hasta C23) en el ámbito circundante y puede utilizarse siempre que se requieran constantes enteras (por ejemplo, como etiqueta de caso o como tamaño de arreglo no VLA).

enum color { RED, GREEN, BLUE } r = RED;
switch(r)
{
case RED:
    puts("rojo");
    break;
case GREEN:
    puts("verde");
    break;
case BLUE:
    puts("azul");
    break;
}

Si enumeration-constant está seguido por = constant-expression , su valor es el valor de esa expresión constante. Si enumeration-constant no está seguido por = constant-expression , su valor es uno mayor que el valor del enumerador anterior en la misma enumeración. El valor del primer enumerador (si no utiliza = constant-expression ) es cero.

enum Foo { A, B, C = 10, D, E = 1, F, G = F + C };
// A=0, B=1, C=10, D=11, E=1, F=2, G=12

El identificador mismo, si se utiliza, se convierte en el nombre del tipo enumerado en el espacio de nombres de etiquetas y requiere el uso de la palabra clave enum (a menos que se defina mediante typedef en el espacio de nombres ordinario).

enum color { RED, GREEN, BLUE };
enum color r = RED; // OK
// color x = GREEN; // Error: color is not in ordinary name space
typedef enum color color_t;
color_t x = GREEN; // OK

Cada tipo enumerado sin un tipo subyacente fijo (since C23) es compatible con uno de: char , un tipo entero con signo, o un tipo entero sin signo (excluyendo bool y los tipos enteros de precisión de bits) (since C23) . Está definido por la implementación qué tipo es compatible con cualquier tipo enumerado dado, pero cualquiera que sea, debe ser capaz de representar todos los valores de enumerador de esa enumeración. Para todas las enumeraciones con un tipo subyacente fijo, el tipo enumerado es compatible con el tipo subyacente de la enumeración. (since C23)

Los tipos enumerados son tipos enteros, y como tales pueden utilizarse en cualquier lugar donde se puedan usar otros tipos enteros, incluyendo en conversiones implícitas y operadores aritméticos .

enum { ONE = 1, TWO } e;
long n = ONE; // promoción
double d = ONE; // conversión
e = 1.2; // conversión, e es ahora ONE
e = e + 1; // e es ahora TWO

Notas

A diferencia de struct o union , no existen enums declarados por adelantado en C:

enum Color; // Error: no forward-declarations for enums in C
enum Color { RED, GREEN, BLUE };

Las enumeraciones permiten la declaración de constantes con nombre de una manera más conveniente y estructurada que #define ; son visibles en el depurador, obedecen las reglas de ámbito y participan en el sistema de tipos.

#define TEN 10
struct S { int x : TEN; }; // CORRECTO

o

enum { TEN = 10 };
struct S { int x : TEN; }; // también correcto

Desde C23 constexpr puede utilizarse para el mismo propósito:

constexpr int TEN = 10;
struct S { int x : TEN; }; // también correcto

Además, como una struct o una union no establece su ámbito en C, un tipo de enumeración y sus constantes de enumeración pueden introducirse en la especificación de miembros de la primera, y su ámbito es el mismo que el de la primera, posteriormente.

struct Element
{
    int z;
    enum State { SOLID, LIQUID, GAS, PLASMA } state;
} oxygen = { 8, GAS };
// el tipo enum State y sus constantes de enumeración permanecen visibles aquí, ej.
void foo(void)
{
    enum State e = LIQUID; // OK
    printf("%d %d %d ", e, oxygen.state, PLASMA); // imprime 1 2 3
}

Ejemplo

#include <stdio.h>
int main(void)
{
    enum TV { FOX = 11, CNN = 25, ESPN = 15, HBO = 22, MAX = 30, NBC = 32 };
    printf("List of cable stations:\n");
    printf(" FOX: \t%2d\n", FOX);
    printf(" HBO: \t%2d\n", HBO);
    printf(" MAX: \t%2d\n", MAX);
}

List of cable stations:
 FOX:   11
 HBO:   22
 MAX:   30

Referencias

Palabras clave

enum

Véase también