C Language
Enumeraciones
Buscar..
Observaciones
Las enumeraciones consisten en la palabra clave enum y un identificador opcional seguido de una lista de enumeradores entre llaves.
Un identificador es de tipo int .
La lista de enumeradores tiene al menos un elemento de enumerador .
A un enumerador se le puede "asignar" opcionalmente una expresión constante de tipo int .
Un enumerador es constante y es compatible con un char , un entero con signo o un entero sin signo. Lo que se usa siempre está definido por la implementación . En cualquier caso, el tipo utilizado debe poder representar todos los valores definidos para la enumeración en cuestión.
Si no se "asigna" una expresión constante a un enumerador y es la primera entrada en una lista de enumeradores , toma el valor de 0 , de lo contrario, toma el valor de la entrada anterior en la lista de enumeradores más 1.
El uso de múltiples "asignaciones" puede llevar a que diferentes enumeradores de la misma enumeración tengan los mismos valores.
Enumeración simple
Una enumeración es un tipo de datos definido por el usuario que consta de constantes integrales y cada constante integral recibe un nombre. La enum palabras clave se utiliza para definir el tipo de datos enumerados.
Si usa enum lugar de int o string/ char* , aumenta la verificación en tiempo de compilación y evita que los errores pasen en constantes no válidas, y documenta qué valores son legales usar.
Ejemplo 1
enum color{ RED, GREEN, BLUE };
void printColor(enum color chosenColor)
{
const char *color_name = "Invalid color";
switch (chosenColor)
{
case RED:
color_name = "RED";
break;
case GREEN:
color_name = "GREEN";
break;
case BLUE:
color_name = "BLUE";
break;
}
printf("%s\n", color_name);
}
Con una función principal definida como sigue (por ejemplo):
int main(){
enum color chosenColor;
printf("Enter a number between 0 and 2");
scanf("%d", (int*)&chosenColor);
printColor(chosenColor);
return 0;
}
Ejemplo 2
(Este ejemplo utiliza inicializadores designados que están estandarizados desde C99).
enum week{ MON, TUE, WED, THU, FRI, SAT, SUN };
static const char* const dow[] = {
[MON] = "Mon", [TUE] = "Tue", [WED] = "Wed",
[THU] = "Thu", [FRI] = "Fri", [SAT] = "Sat", [SUN] = "Sun" };
void printDayOfWeek(enum week day)
{
printf("%s\n", dow[day]);
}
El mismo ejemplo usando la verificación de rango:
enum week{ DOW_INVALID = -1,
MON, TUE, WED, THU, FRI, SAT, SUN,
DOW_MAX };
static const char* const dow[] = {
[MON] = "Mon", [TUE] = "Tue", [WED] = "Wed",
[THU] = "Thu", [FRI] = "Fri", [SAT] = "Sat", [SUN] = "Sun" };
void printDayOfWeek(enum week day)
{
assert(day > DOW_INVALID && day < DOW_MAX);
printf("%s\n", dow[day]);
}
Typedef enum
Hay varias posibilidades y convenciones para nombrar una enumeración. La primera es usar un nombre de etiqueta justo después de la palabra clave enum .
enum color
{
RED,
GREEN,
BLUE
};
Esta enumeración se debe usar siempre con la palabra clave y la etiqueta como esta:
enum color chosenColor = RED;
Si usamos typedef directamente al declarar la enum , podemos omitir el nombre de la etiqueta y luego usar el tipo sin la palabra clave enum :
typedef enum
{
RED,
GREEN,
BLUE
} color;
color chosenColor = RED;
Pero en este último caso no podemos usarlo como enum color , porque no usamos el nombre de la etiqueta en la definición. Una convención común es usar ambos, de modo que se pueda usar el mismo nombre con o sin la palabra clave enum . Esto tiene la ventaja particular de ser compatible con C ++
enum color /* as in the first example */
{
RED,
GREEN,
BLUE
};
typedef enum color color; /* also a typedef of same identifier */
color chosenColor = RED;
enum color defaultColor = BLUE;
Función:
void printColor()
{
if (chosenColor == RED)
{
printf("RED\n");
}
else if (chosenColor == GREEN)
{
printf("GREEN\n");
}
else if (chosenColor == BLUE)
{
printf("BLUE\n");
}
}
Para más información sobre typedef ver Typedef
Enumeración con valor duplicado
Un valor de enumeración de ninguna manera debe ser único:
#include <stdlib.h> /* for EXIT_SUCCESS */
#include <stdio.h> /* for printf() */
enum Dupes
{
Base, /* Takes 0 */
One, /* Takes Base + 1 */
Two, /* Takes One + 1 */
Negative = -1,
AnotherZero /* Takes Negative + 1 == 0, sigh */
};
int main(void)
{
printf("Base = %d\n", Base);
printf("One = %d\n", One);
printf("Two = %d\n", Two);
printf("Negative = %d\n", Negative);
printf("AnotherZero = %d\n", AnotherZero);
return EXIT_SUCCESS;
}
La muestra se imprime:
Base = 0
One = 1
Two = 2
Negative = -1
AnotherZero = 0
constante de enumeración sin nombre tipográfico
Los tipos de enumeración también se pueden declarar sin darles un nombre:
enum { buffersize = 256, };
static unsigned char buffer [buffersize] = { 0 };
Esto nos permite definir constantes de tiempo de compilación de tipo int que, como en este ejemplo, se pueden usar como longitud de matriz.