Enum Classes y tipado fuerte

Parte de la sección Programación Orientada a Objetos del Journey de C++ de Coddy — lección 80 de 104.

C++11 introdujo las enum classes (también llamadas enumeraciones con alcance) para abordar las deficiencias de las enumeraciones tradicionales de estilo C. Proporcionan una mayor seguridad de tipos y evitan el uso indebido accidental de los valores de enumeración.

Los enums tradicionales tienen problemas: sus valores se filtran al ámbito circundante y se convierten implícitamente en enteros, lo que provoca errores sutiles:

// Enum tradicional - problemático
enum Color { Red, Green, Blue };
enum TrafficLight { Red, Yellow, Green };  // ¡Error! Red y Green ya están definidos

int x = Red;  // Se convierte implícitamente a int (0)
if (Red == 0) { }  // Compila - comparando enum con int

Las clases enum resuelven estos problemas al delimitar el ámbito de los valores y evitar las conversiones implícitas:

enum class Color { Red, Green, Blue };
enum class TrafficLight { Red, Yellow, Green };  // Correcto - sin conflicto

Color c = Color::Red;      // Debe usar el operador de ámbito
// int x = c;              // ¡Error! Sin conversión implícita
int x = static_cast<int>(c);  // Se requiere conversión explícita

// if (c == 0) { }         // ¡Error! No se puede comparar con int
if (c == Color::Red) { }   // Correcto - comparando los mismos tipos

También puedes especificar el tipo subyacente para el control de memoria:

enum class Status : uint8_t {
    Inactive = 0,
    Active = 1,
    Pending = 2
};

Las clases Enum se integran bien con los diseños de POO, haciendo que el código sea más legible y detectando errores de tipo en tiempo de compilación en lugar de en tiempo de ejecución.

Desafío

Fácil

Vamos a construir un sistema de prioridad de tareas que utiliza clases enum para representar diferentes niveles de prioridad y estados de tareas. Esto demuestra cómo las clases enum proporcionan seguridad de tipos y evitan los tipos de errores que ocurren con los enums tradicionales.

Organizarás tu código en tres archivos:

TaskTypes.h: Define tus clases enum para el sistema de tareas.
Crea una clase enum Priority con los valores: Low, Medium, High y Critical. Especifica int como el tipo subyacente, con los valores 1, 2, 3 y 4 respectivamente.

Crea una clase enum Status con los valores: Pending, InProgress y Completed.

Proporciona dos funciones auxiliares:
- priorityToString(Priority p) — devuelve la prioridad como un string ("Low", "Medium", "High" o "Critical")
- statusToString(Status s) — devuelve el estado como un string ("Pending", "InProgress" o "Completed")
Task.h: Define una clase Task que utilice tus clases enum.
Tu Task debe almacenar un nombre (string), una Priority y un Status. El constructor debe recibir un nombre y una prioridad, con el estado por defecto en Status::Pending.

Implementa estos métodos:
- setStatus(Status s) — actualiza el estado de la tarea
- getPriorityValue() — devuelve el valor entero subyacente de la prioridad utilizando static_cast
- display() — imprime la tarea en el formato: [name] - Priority: [priority] (Value: [value]) - Status: [status]
main.cpp: Lee tres entradas:
1. Nombre de la tarea (string)
2. Nivel de prioridad como entero (1=Low, 2=Medium, 3=High, 4=Critical)
3. Estado como entero (0=Pending, 1=InProgress, 2=Completed)
Crea una Task con el nombre y la prioridad dados (convierte el entero al valor de enum Priority apropiado utilizando static_cast). Luego establece su estado basándote en la tercera entrada. Finalmente, llama a display() para mostrar los detalles de la tarea.

Por ejemplo, con las entradas Fix bug, 3 y 1:

Fix bug - Priority: High (Value: 3) - Status: InProgress

Con las entradas Write docs, 1 y 2:

Write docs - Priority: Low (Value: 1) - Status: Completed

Con las entradas Deploy app, 4 y 0:

Deploy app - Priority: Critical (Value: 4) - Status: Pending

Observa cómo las clases enum mantienen los valores de prioridad y estado completamente separados; no puedes comparar accidentalmente una Priority con un Status ni asignar uno al otro. El static_cast explícito requerido para convertir entre enteros y valores de enum hace que la intención del código sea clara y evita errores sutiles.

Hoja de referencia

C++11 introdujo las enum classes (enumeraciones con ámbito) para proporcionar una seguridad de tipos más sólida que las enumeraciones tradicionales de estilo C.

Las enumeraciones tradicionales tienen problemas con la fuga de ámbito y las conversiones implícitas:

// Traditional enum - problematic
enum Color { Red, Green, Blue };
enum TrafficLight { Red, Yellow, Green };  // Error! Red and Green already defined

int x = Red;  // Implicitly converts to int
if (Red == 0) { }  // Compiles - comparing enum to int

Las enum classes resuelven estos problemas al requerir la resolución de ámbito y evitar las conversiones implícitas:

enum class Color { Red, Green, Blue };
enum class TrafficLight { Red, Yellow, Green };  // OK - no conflict

Color c = Color::Red;      // Must use scope operator
// int x = c;              // Error! No implicit conversion
int x = static_cast<int>(c);  // Explicit conversion required

// if (c == 0) { }         // Error! Can't compare to int
if (c == Color::Red) { }   // OK - comparing same types

Puede especificar el tipo subyacente para el control de memoria:

enum class Status : uint8_t {
    Inactive = 0,
    Active = 1,
    Pending = 2
};

Para convertir entre enum classes y enteros, use el moldeado explícito (explicit casting):

// Integer to enum class
Priority p = static_cast<Priority>(3);

// Enum class to integer
int value = static_cast<int>(p);

Pruébalo tú mismo

#include <iostream>
#include <string>
#include "Task.h"

using namespace std;

int main() {
    // Leer las entradas
    string taskName;
    int priorityInt;
    int statusInt;
    
    getline(cin, taskName);
    cin >> priorityInt;
    cin >> statusInt;
    
    // TODO: Crear una Task con el nombre y la prioridad dados
    // Usar static_cast para convertir priorityInt al enum Priority
    
    // TODO: Establecer el estado de la tarea basándose en statusInt
    // Usar static_cast para convertir statusInt al enum Status
    
    // TODO: Llamar a display() para mostrar los detalles de la tarea
    
    return 0;
}