Classes enum et typage fort

Fait partie de la section Programmation Orientée Objet du Journey C++ de Coddy. Leçon 80 sur 104.

C++11 a introduit les classes enum (également appelées énumérations à portée contrôlée) pour remédier aux limitations des énumérations traditionnelles de style C. Elles offrent une sécurité de typage renforcée et empêchent l’utilisation accidentelle et incorrecte des valeurs d’énumération.

Les énumérations traditionnelles posent des problèmes : leurs valeurs se propagent dans la portée environnante et se convertissent implicitement en entiers, ce qui entraîne des bugs subtils :

// Enum traditionnel - problématique
enum Color { Red, Green, Blue };
enum TrafficLight { Red, Yellow, Green };  // Erreur ! Red et Green déjà définis

int x = Red;  // Convertit implicitement en int (0)
if (Red == 0) { }  // Compile - comparaison d'enum à int

Les classes d’énumération résolvent ces problèmes en limitant la portée des valeurs et en empêchant les conversions implicites :

enum class Color { Red, Green, Blue };
enum class TrafficLight { Red, Yellow, Green };  // OK - pas de conflit

Color c = Color::Red;      // Doit utiliser l'opérateur de portée
// int x = c;              // Erreur ! Pas de conversion implicite
int x = static_cast<int>(c);  // Conversion explicite requise

// if (c == 0) { }         // Erreur ! Impossible de comparer à int
if (c == Color::Red) { }   // OK - comparaison des mêmes types

Vous pouvez également spécifier le type sous-jacent pour contrôler la mémoire :

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

Les classes enum s’intègrent bien aux conceptions orientées objet, rendant le code plus lisible et détectant les erreurs de type lors de la compilation plutôt qu’à l’exécution.

Défi

Facile

Construisons un système de priorité des tâches qui utilise des classes d’énumération pour représenter différents niveaux de priorité et statuts de tâche. Cela montre comment les classes d’énumération assurent la sécurité des types et empêchent les types de bogues qui se produisent avec les énumérations traditionnelles.

Vous organiserez votre code dans trois fichiers :

TaskTypes.h : définissez vos classes d’énumération pour le système de tâches.
Créez une classe d’énumération Priority avec les valeurs suivantes : Low, Medium, High et Critical. Spécifiez int comme type sous-jacent, avec les valeurs 1, 2, 3 et 4 respectivement.

Créez une classe d’énumération Status avec les valeurs suivantes : Pending, InProgress et Completed.

Fournissez deux fonctions d’aide :
- priorityToString(Priority p) : renvoie la priorité sous forme de chaîne ("Low", "Medium", "High" ou "Critical")
- statusToString(Status s) : renvoie le statut sous forme de chaîne ("Pending", "InProgress" ou "Completed")
Task.h : définissez une classe Task qui utilise vos classes d’énumération.
Votre Task doit stocker un nom (chaîne), une Priority et un Status. Le constructeur doit accepter un nom et une priorité, le statut prenant par défaut la valeur Status::Pending.

Implémentez ces méthodes :
- setStatus(Status s) : met à jour le statut de la tâche
- getPriorityValue() : renvoie la valeur entière sous-jacente de la priorité à l’aide de static_cast
- display() : affiche la tâche au format suivant : [name] - Priority: [priority] (Value: [value]) - Status: [status]
main.cpp : lisez trois entrées :
1. Nom de la tâche (chaîne)
2. Niveau de priorité sous forme d’entier (1=Low, 2=Medium, 3=High, 4=Critical)
3. Statut sous forme d’entier (0=Pending, 1=InProgress, 2=Completed)
Créez une Task avec le nom et la priorité fournis (convertissez l’entier en valeur d’énumération Priority appropriée à l’aide de static_cast). Définissez ensuite son statut en fonction de la troisième entrée. Enfin, appelez display() pour afficher les détails de la tâche.

Par exemple, avec les entrées Fix bug, 3 et 1 :

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

Avec les entrées Write docs, 1 et 2 :

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

Avec les entrées Deploy app, 4 et 0 :

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

Remarquez comment les classes d’énumération maintiennent les valeurs de priorité et de statut complètement séparées. Vous ne pouvez pas comparer accidentellement une Priority à un Status, ni affecter l’une à l’autre. Le static_cast explicite requis pour effectuer une conversion entre des entiers et des valeurs d’énumération rend l’intention du code claire et empêche les bogues subtils.

Essayez vous-même

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

using namespace std;

int main() {
    // Lire les entrées
    string taskName;
    int priorityInt;
    int statusInt;
    
    getline(cin, taskName);
    cin >> priorityInt;
    cin >> statusInt;
    
    // TODO: Créer un Task avec le nom et la priorité donnés
    // Utiliser static_cast pour convertir priorityInt en enum Priority
    
    // TODO: Définir le statut de la tâche en fonction de statusInt
    // Utiliser static_cast pour convertir statusInt en enum Status
    
    // TODO: Appeler display() pour afficher les détails de la tâche
    
    return 0;
}