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 clases enum (también llamadas enumeraciones con ámbito) 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 presentan 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 los valores y evitar las conversiones implícitas:

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

Color c = Color::Red;      // Debe usar el operador de alcance
// int x = c;              // ¡Error! No hay 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) { }   // OK - comparando los mismos tipos

También puedes especificar el tipo subyacente para controlar la memoria:

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

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

Desafío

Fácil

Construyamos un sistema de prioridades de tareas que use clases enum para representar distintos niveles de prioridad y estados de tarea. 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 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 una cadena ("Low", "Medium", "High" o "Critical")
- statusToString(Status s): devuelve el estado como una cadena ("Pending", "InProgress" o "Completed")
Task.h: Define una clase Task que use tus clases enum.
Tu Task debe almacenar un nombre (cadena), un Priority y un Status. El constructor debe recibir un nombre y una prioridad, con el estado predeterminado 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 mediante static_cast
- display(): muestra la tarea con el formato: [name] - Priority: [priority] (Value: [value]) - Status: [status]
main.cpp: Lee tres entradas:
1. Nombre de la tarea (cadena)
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 un Task con el nombre y la prioridad proporcionados (convierte el entero al valor de enum Priority correspondiente mediante static_cast). Después, establece su estado según la tercera entrada. Por último, 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 completamente separados los valores de prioridad y de estado. No puedes comparar accidentalmente un Priority con un Status ni asignar uno al otro. El static_cast explícito necesario para convertir entre enteros y valores enum hace que la intención del código sea clara y evita errores sutiles.

Pruébalo tú mismo

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

using namespace std;

int main() {
    // Lee las entradas
    string taskName;
    int priorityInt;
    int statusInt;
    
    getline(cin, taskName);
    cin >> priorityInt;
    cin >> statusInt;
    
    // TODO: Crea un Task con el nombre y la prioridad dados
    // Usa static_cast para convertir priorityInt al enum Priority
    
    // TODO: Establece el estado de la tarea basándote en statusInt
    // Usa static_cast para convertir statusInt al enum Status
    
    // TODO: Llama a display() para mostrar los detalles de la tarea
    
    return 0;
}