Capítulo 4: Enumeraciones y Switch Statements

Las enumeraciones te permiten crear tus propios tipos con un conjunto fijo de valores nombrados. En lugar de usar números "mágicos" como 0, 1, 2, usas nombres significativos como Status::Connected. Esto hace tu código más legible y seguro.

Objetivos

• Entender qué es y para qué sirve enum class
• Crear y usar tus propias enumeraciones
• Dominar el switch statement para control de flujo
• Conocer las diferencias entre enum y enum class
• Evitar el bug común de "fall-through"

El problema: números mágicos

Imagina que estás programando una conexión de red. Podrías representar el estado usando números enteros para cada condición:

// [X] Código confuso con "números mágicos"
int connection_status = 2;

if (connection_status == 0) {
    std::cout << "Desconocido
";
} else if (connection_status == 1) {
    std::cout << "Conectando
";
} else if (connection_status == 2) {
    std::cout << "Conectado
";
}
// Que significa 2? Por que no 3? Confuso...

¿Qué son "números mágicos"? Son valores literales (como 0, 1, 2) cuyo significado no es evidente al leerlos. Se llaman "mágicos" porque parecen aparecer de la nada sin explicación. Cuando lees if (status == 2), no tienes idea de qué significa "2" sin consultar documentación o comentarios.

¿Por qué son problemáticos? Los números mágicos hacen el código difícil de mantener. Si necesitas agregar un nuevo estado, debes encontrar todos los lugares donde se usa ese número. Si dos desarrolladores asignan el mismo número a diferentes estados en partes diferentes del código, tendrás bugs sutiles y difíciles de rastrear.

La solución: enum class

#include <iostream>

// Definición de enumeración
enum class Status { Unknown, Connecting, Connected, Disconnected };

int main() {
    Status connection_status = Status::Connected;

    if (connection_status == Status::Connected) {
        std::cout << "Estamos conectados!
";
    }

    return 0;
}

Ventajas

• ✅ Legible: Status::Connected es autoexplicativo
• ✅ Type-safe: No puedes asignar valores inválidos
• ✅ Scope: Los valores están encapsulados en el enum
• ✅ Mantenible: Fácil agregar nuevos estados

Anatomía de enum class

flowchart TB
    A["enum class Status"] --> B["enum class"]
    A --> C["Status"]
    A --> D["Valores"]

    B --> B1["Palabra clave<br/>enum class"]
    C --> C1["Nombre del tipo"]
    D --> D1["Valores enumerados<br/>(separados por comas)"]

    E["Uso:"] --> E1["Status::Unknown"]
    E1 --> E2["Status = Tipo"]
    E1 --> E3[":: = Operador de scope"]
    E1 --> E4["Unknown = Valor"]

    style A fill:#e1f5fe,stroke:#0277bd,stroke-width:3px
    style B fill:#fff3e0,stroke:#e65100,stroke-width:2px
    style C fill:#f3e5f5,stroke:#6a1b9a,stroke-width:2px
    style D fill:#e8f5e9,stroke:#2e7d32,stroke-width:2px

Por defecto, cada valor de un enum internamente

Cada valor de un enum se mapea a un entero secuencial empezando desde 0.

Puedes ver el valor con: static_cast<int>(Status::Connected)

También puedes especificar valores manuales: enum class HttpStatus { OK = 200, NotFound = 404 }

Por defecto, un enum class usa tipo subyacente de enum

El tipo de dato usado internamente para almacenar los valores del enum. Por defecto es int (4 bytes).

Puedes especificar otro tipo: enum class SmallEnum : uint8_t { A, B, C }; (solo 1 byte).

Útil para ahorrar memoria en arrays grandes de enums.

// Estilo viejo: enum (sin class)
enum OldStatus { Unknown, Connected };

// Uso:
OldStatus s = Connected;  // No requiere OldStatus::
int x = Connected;        // [X] Se convierte implícitamente a int!

// Estilo moderno: enum class
enum class NewStatus { Unknown, Connected };

// Uso:
NewStatus s = NewStatus::Connected;  // [OK] Requiere scope
int x = NewStatus::Connected;        // [X] ERROR: no convierte a int

Switch statements

El switch es perfecto para trabajar con enums. Evalúa una expresión y ejecuta código diferente según el caso:

enum class Status { Unknown, Connecting, Connected, Disconnected };

void print_status(Status s) {
    switch (s) {
        case Status::Unknown:
            std::cout << "Estado desconocido
";
            break;

        case Status::Connecting:
            std::cout << "Conectando...
";
            break;

        case Status::Connected:
            std::cout << "¡Conectado!
";
            break;

        case Status::Disconnected:
            std::cout << "Desconectado
";
            break;

        default:
            std::cout << "Estado inválido
";
            break;
    }
}

Componentes del switch

• switch (expresión) - Evalúa la expresión una vez
• case valor: - Si la expresión == valor, ejecuta este bloque
• break; - Sale del switch (MUY IMPORTANTE)
• default: - Se ejecuta si ningún case coincide (opcional)

switch (s) {
    case Status::Connecting:
        std::cout << "Conectando...
";
        // [X] ¡FALTA break!

    case Status::Connected:
        std::cout << "Conectado
";
        break;
}

// Si s == Status::Connecting, imprime:
// Conectando...
// Conectado      ← ¡También ejecutó este caso!

A veces quieres fall-through intencional

Cuando múltiples casos de un switch ejecutan el mismo código intencionalmente.

Ejemplo: case Sat: case Sun: cout << 'Fin de semana'; break;

En C++17 puedes documentarlo con [[fallthrough]]; para indicar que no es un error.

enum class Day { Mon, Tue, Wed, Thu, Fri, Sat, Sun };

void check_day(Day d) {
    switch (d) {
        case Day::Sat:
        case Day::Sun:
            std::cout << "¡Fin de semana!
";
            break;

        case Day::Mon:
        case Day::Tue:
        case Day::Wed:
        case Day::Thu:
        case Day::Fri:
            std::cout << "Día laboral
";
            break;
    }
}

Ejemplo completo

#include <iostream>

enum class UserPermission { Read = 1, Write = 2, Execute = 4, Admin = 8 };

enum class Status { Unknown, Connecting, Connected, Disconnected };

void print_permission(UserPermission p) {
    switch (p) {
        case UserPermission::Read:
            std::cout << "Permiso de lectura
";
            break;

        case UserPermission::Write:
            std::cout << "Permiso de escritura
";
            break;

        case UserPermission::Execute:
            std::cout << "Permiso de ejecución
";
            break;

        case UserPermission::Admin:
            std::cout << "Permiso de administrador
";
            break;

        default:
            std::cout << "Permiso desconocido
";
            break;
    }
}

int main() {
    Status s = Status::Connected;

    switch (s) {
        case Status::Unknown:
            std::cout << "?
";
            break;

        case Status::Connecting:
            std::cout << "...
";
            break;

        case Status::Connected:
            std::cout << "✓
";
            break;

        case Status::Disconnected:
            std::cout << "✗
";
            break;
    }

    UserPermission perm = UserPermission::Admin;
    print_permission(perm);

    // Convertir a int si realmente lo necesitas
    int perm_value = static_cast<int>(perm);
    std::cout << "Valor: " << perm_value << "
";  // 8

    return 0;
}

Checklist

• Sé declarar un enum class con valores nombrados
• Entiendo que los valores por defecto empiezan en 0
• Uso la sintaxis NombreEnum::Valor correctamente
• Puedo escribir un switch completo con todos los casos
• NUNCA olvido el break al final de cada caso
• Sé cuándo usar default: en un switch
• Prefiero enum class sobre enum simple

Preguntas para reflexionar