Docs ejecutables de C: enums

Q: ¿Cómo se define un enum en C?

enum Color { RED, GREEN, BLUE }; define un tipo cuyos valores son las tres constantes con nombre. Por defecto se numeran desde 0, así que RED es 0, GREEN es 1 y BLUE es 2. Declara una variable con enum Color c = GREEN;, o agrega un typedef para poder escribir solo Color c.

Q: ¿Se pueden asignar valores específicos a un enum en C?

Sí: enum Status { OK = 200, NOT_FOUND = 404, ERROR = 500 };. Puedes fijar algunos y dejar que los otros sigan: cualquier nombre sin valor explícito continúa desde el anterior, así que enum { A = 10, B, C }; da B = 11 y C = 12.

Q: ¿Cuál es el tamaño de un enum en C?

Definido por la implementación, pero en la práctica sizeof(int): 4 bytes en la mayoría de los sistemas. El compilador elige un tipo entero capaz de contener a todos los enumeradores. No asumas un tamaño específico al armar un archivo binario o un paquete de red; usa ahí un tipo de ancho fijo de .

El código lleno de números pelados es código que nadie puede leer. if (state == 2) no te dice nada; if (state == STATE_RUNNING) te lo dice todo. Un enum es la manera de C de darle nombres propios a un conjunto pequeño y fijo de enteros, y a diferencia de un montón de #define, vienen agrupados en un tipo que el compilador conoce.

Definir un enum

La declaración nombra una etiqueta y lista los enumeradores entre llaves:

#include <stdio.h>

enum Color {
    RED,
    GREEN,
    BLUE
};

int main(void) {
    enum Color favorite = GREEN;

    printf("favorito = %d\n", favorite);
    printf("RED=%d GREEN=%d BLUE=%d\n", RED, GREEN, BLUE);
    return 0;
}

Dos cosas que hay que notar de inmediato. Primero, la numeración empieza en 0 y aumenta de uno en uno, así que RED es 0, GREEN es 1 y BLUE es 2. Segundo, los nombres de los enumeradores son visibles en todo el alcance que los envuelve: escribes GREEN, no Color.GREEN. Viven en el mismo espacio de nombres que tus variables, que es por lo que el código C convencionalmente los GRITA o los prefija por tipo (COLOR_RED) para evitar colisiones.

Imprimir un enum usa %d, porque un valor de enumeración es un valor entero.

Valores explícitos

Asigna a cualquier enumerador una constante explícita, y los que siguen continúan desde ahí:

#include <stdio.h>

enum HttpStatus {
    HTTP_OK        = 200,
    HTTP_CREATED   = 201,
    HTTP_NOT_FOUND = 404,
    HTTP_ERROR     = 500
};

enum Level {
    LOW = 10,
    MEDIUM,          /* 11 */
    HIGH,            /* 12 */
    CRITICAL = 100,
    EXTREME          /* 101 */
};

int main(void) {
    printf("%d %d %d %d\n", HTTP_OK, HTTP_CREATED, HTTP_NOT_FOUND, HTTP_ERROR);
    printf("%d %d %d %d %d\n", LOW, MEDIUM, HIGH, CRITICAL, EXTREME);
    return 0;
}

Los valores no tienen que ser únicos ni estar ordenados: dos enumeradores pueden compartir un número, lo que ocasionalmente es útil para alias (COLOR_DEFAULT = COLOR_BLACK). Deben ser constantes enteras de tiempo de compilación, así que no puedes calcular uno a partir de una variable.

Un modismo común usa esto para registrar la cantidad:

enum Suit {
    CLUBS, DIAMONDS, HEARTS, SPADES,
    SUIT_COUNT           /* automáticamente 4 - sigue siendo correcto si agregas un palo */
};

SUIT_COUNT no es un palo real; es cuántos hay, mantenido gratis por la numeración automática. Los bucles y los tamaños de arrays pueden usarlo y nunca quedar desactualizados.

typedef enum

Igual que con los structs, el nombre completo del tipo en C es enum Color, y un typedef elimina la palabra clave:

#include <stdio.h>

typedef enum Direction {
    DIR_NORTH,
    DIR_EAST,
    DIR_SOUTH,
    DIR_WEST,
    DIR_COUNT
} Direction;

int main(void) {
    const int dx[DIR_COUNT] = {0, 1, 0, -1};
    const int dy[DIR_COUNT] = {-1, 0, 1, 0};

    int x = 0, y = 0;
    Direction path[] = {DIR_EAST, DIR_EAST, DIR_SOUTH, DIR_WEST};

    for (size_t i = 0; i < sizeof path / sizeof path[0]; i++) {
        x += dx[path[i]];
        y += dy[path[i]];
    }

    printf("termino en (%d, %d)\n", x, y);
    return 0;
}

Como los enumeradores son enteros ordinarios que empiezan en 0, sirven también como índices de array: dx[DIR_EAST] funciona sin ninguna conversión. Esa es la propiedad más útil de un enum basado en cero.

Enums en un switch

Emparejar un enum con un switch es donde el tipo empieza a pagarse solo. Compila con -Wall y el compilador te dirá cuándo olvidaste un caso.

#include <stdio.h>

typedef enum {
    STATE_IDLE,
    STATE_RUNNING,
    STATE_PAUSED,
    STATE_STOPPED
} State;

const char *describe(State s) {
    switch (s) {
        case STATE_IDLE:    return "esperando trabajo";
        case STATE_RUNNING: return "trabajando";
        case STATE_PAUSED:  return "pausado por el usuario";
        case STATE_STOPPED: return "terminado";
    }
    return "desconocido";
}

int main(void) {
    for (State s = STATE_IDLE; s <= STATE_STOPPED; s++) {
        printf("%d: %s\n", s, describe(s));
    }
    return 0;
}

Agrega un STATE_FAILED al enum y GCC advierte: enumeration value 'STATE_FAILED' not handled in switch. Esa advertencia es lo más parecido que C tiene a una comprobación de exhaustividad, y es una razón fuerte para escribir estos switches sin un caso default:: un default silencia la advertencia y deja que los estados nuevos pasen sin manejar. Pon el respaldo después del switch en su lugar, como hace describe.

Convertir un enum a cadena

C no guarda nombres en tiempo de ejecución; printf("%s", GREEN) no puede funcionar porque GREEN es simplemente 1. Dos patrones lo resuelven.

La versión con switch, que el compilador verifica:

#include <stdio.h>

typedef enum { RED, GREEN, BLUE, COLOR_COUNT } Color;

const char *color_name(Color c) {
    switch (c) {
        case RED:   return "RED";
        case GREEN: return "GREEN";
        case BLUE:  return "BLUE";
        case COLOR_COUNT: break;
    }
    return "UNKNOWN";
}

int main(void) {
    for (Color c = RED; c < COLOR_COUNT; c++) {
        printf("%d = %s\n", c, color_name(c));
    }
    return 0;
}

Y la versión con tabla de búsqueda, más corta pero sin verificar: si el array y el enum se separan, nada advierte.

#include <stdio.h>

typedef enum { RED, GREEN, BLUE, COLOR_COUNT } Color;

static const char *COLOR_NAMES[COLOR_COUNT] = {
    [RED]   = "RED",
    [GREEN] = "GREEN",
    [BLUE]  = "BLUE",
};

const char *color_name(Color c) {
    if (c < 0 || c >= COLOR_COUNT) {
        return "UNKNOWN";
    }
    return COLOR_NAMES[c];
}

int main(void) {
    printf("%s %s %s\n", color_name(RED), color_name(GREEN), color_name(BLUE));
    printf("%s\n", color_name((Color)99));
    return 0;
}

Los índices designados del array ([RED] = "RED") al menos mantienen los nombres pegados a sus casillas, así que reordenar el enum no puede barajar las cadenas en silencio. La comprobación de límites importa porque nada impide que quien llama pase un valor fuera del enum: mira la sección siguiente.

Los enums no son herméticos

Una variable de enum es un entero por debajo, y C no vigila el rango:

#include <stdio.h>

typedef enum { RED, GREEN, BLUE } Color;

int main(void) {
    Color c = (Color)42;      /* legal; ninguna comprobación */
    int n = BLUE;             /* enum a int: implícito y correcto */

    printf("c = %d, n = %d\n", c, n);
    printf("RED + GREEN = %d\n", RED + GREEN);
    return 0;
}

La aritmética sobre enumeradores funciona, las comparaciones con ints simples funcionan, y una conversión fuera de rango se acepta. Así que trata un enum como excelente documentación y una buena pista para el compilador, no como una garantía. Valida cualquier valor que llegue de fuera de tu programa — un archivo, un argumento, un mensaje de red — antes de hacerle switch.

Tamaño y almacenamiento

En C17, todo enumerador debe caber en un int: enum Huge { BIG = 3000000000 }; es una violación de restricción que un compilador estricto (-pedantic-errors) rechaza, aunque gcc y clang la acepten como extensión en su modo por defecto. Los enumeradores en sí tienen tipo int, mientras que el tamaño del tipo enum está definido por la implementación (en la práctica, int):

#include <stdio.h>

enum Small { A, B, C };
enum Flags { READ = 1, WRITE = 2, EXEC = 4 };

int main(void) {
    printf("sizeof(enum Small) = %zu\n", sizeof(enum Small));
    printf("sizeof(enum Flags) = %zu\n", sizeof(enum Flags));
    printf("sizeof(int)        = %zu\n", sizeof(int));
    return 0;
}

(C23 levanta la restricción: un enumerador puede exceder el rango de int e incluso puedes elegir el tipo subyacente con enum E : unsigned long { ... }. Hasta que tu cadena de herramientas apunte a C23, mantén los enumeradores dentro de int.)

Como la elección exacta está definida por la implementación, nunca escribas un enum directamente en un archivo binario o un paquete de red y esperes que otra máquina lo lea de vuelta. Convierte a un tipo de ancho fijo como uint8_t o uint32_t de <stdint.h> en la frontera.

Enum frente a #define

Ambos le dan un nombre a un número. El enum es generalmente mejor:

	`enum`	`#define`
Lo maneja	el compilador	el preprocesador
Agrupación	los valores relacionados comparten un tipo	cada constante es independiente
Numeración automática	sí	no, numeras a mano
Visible en un depurador	a menudo, por nombre	no, solo el número
Advertencia de exhaustividad en `switch`	sí	no
Alcance	respeta el alcance de bloque	textual, hasta `#undef`

Recurre a #define cuando la constante no sea un entero (una cadena, un float) o cuando deba ser utilizable por el propio preprocesador, como en compilación condicional. Para un conjunto de estados, banderas o clases enteras relacionadas, usa un enum.

Convenciones de nombres

Los enums chocan con facilidad porque sus nombres viven en el alcance ordinario. Las convenciones que mantienen cuerdas a las bases de código grandes de C:

Prefija cada enumerador con el tipo: COLOR_RED, STATE_IDLE, HTTP_OK. Un RED sin prefijo en un programa de gráficos terminará encontrándose con el RED de alguien más.
Escribe los enumeradores en MAYUSCULAS, igual que se ven las demás constantes.
Nombra el tipo en PascalCase singular o snake_case_t: Color, State o color_t, de forma consistente en todo el proyecto.
Agrega un centinela _COUNT al final cuando vayas a iterar o indexar con el enum.

Preguntas frecuentes

¿Cómo se define un enum en C?

enum Color { RED, GREEN, BLUE }; define un tipo cuyos valores son las tres constantes con nombre. Por defecto se numeran desde 0, así que RED es 0, GREEN es 1 y BLUE es 2. Declara una variable con enum Color c = GREEN;, o agrega un typedef para poder escribir solo Color c.

¿Se pueden asignar valores específicos a un enum en C?

Sí: enum Status { OK = 200, NOT_FOUND = 404, ERROR = 500 };. Puedes fijar algunos y dejar que los otros sigan: cualquier nombre sin valor explícito continúa desde el anterior, así que enum { A = 10, B, C }; da B = 11 y C = 12.

¿Cómo se convierte un enum a cadena en C?

C no tiene una forma integrada; los nombres de los enumeradores no existen en tiempo de ejecución. El enfoque habitual es una función pequeña con un switch que devuelve un literal de cadena por valor, o un array de cadenas indexado por el enum. La versión con switch es más segura porque -Wall advierte cuando un enumerador nuevo no tiene caso.

¿Cuál es el tamaño de un enum en C?

Definido por la implementación, pero en la práctica sizeof(int): 4 bytes en la mayoría de los sistemas. El compilador elige un tipo entero capaz de contener a todos los enumeradores. No asumas un tamaño específico al armar un archivo binario o un paquete de red; usa ahí un tipo de ancho fijo de <stdint.h>.

Conceptos relacionados