Enum in C++: enum class ed enum semplice a confronto

A cosa serve un enum

Una struct raggruppa più valori correlati in un unico oggetto. Un enum risolve un problema diverso: dà un nome a un insieme piccolo e fisso di scelte. Invece di ricordarti che 0 significa "rosso", 1 significa "verde" e 2 significa "blu", scrivi Color::Red e il compilatore ti tiene sulla retta via.

Usare un enum ogni volta che una variabile può trovarsi solo in uno fra pochi stati con un nome, come il colore di un semaforo, il seme di una carta o lo stato di una connessione, rende il codice autoesplicativo e permette al compilatore di intercettare errori di battitura e casi mancanti che con dei semplici interi non vedrebbe mai.

Dichiarare un enum

Il C++ moderno ne ha due varianti. Parti da quella da usare quasi sempre: l'enum class con scope. Elenchi i nomi, e a ogni enumeratore si accede tramite il nome dell'enum con :::

#include <iostream>
using namespace std;

enum class Color { Red, Green, Blue };

int main() {
    Color c = Color::Green;

    if (c == Color::Green) {
        cout << "It's green!" << endl;
    }

    return 0;
}

Nota che scrivi Color::Green, mai un Green isolato. I valori in sé sono solo etichette: li confronti, li assegni e li passi in giro, ma raramente ti interessa il numero sottostante. Di default Red vale 0, Green vale 1 e Blue vale 2, contando a partire da zero.

enum semplice ed enum class

Il vecchio enum senza scope (senza la parola chiave class) mette i suoi nomi direttamente nello scope circostante e si converte in int da solo. Sembra comodo, ma causa due problemi reali:

enum Color { Red, Green, Blue };
enum Fruit { Apple, Banana, Red };  // error: 'Red' already declared

enum Status { Active, Inactive };
int x = Active;          // compiles silently - is this what you meant?
if (Active == Banana) {  // compares unrelated enums via int - allowed!
}

Dato che gli enumeratori semplici sono nomi globali, due enum possono entrare in conflitto solo perché condividono un'etichetta. E dato che decadono a int, il compilatore confronta tranquillamente valori di enum che non hanno nulla a che fare tra loro. Un enum class con scope risolve entrambi i problemi: i nomi vivono dentro il tipo, e il tipo non si trasforma in silenzio in un int:

#include <iostream>
using namespace std;

enum class Status { Active, Inactive };
enum class Fruit { Apple, Banana };

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

    // s == Fruit::Apple;     // won't compile - different types, good
    // int x = s;             // won't compile - no implicit conversion

    cout << (s == Status::Active) << endl;  // prints 1 (true)
    return 0;
}

La regola pratica: usa enum class di default. Ripiega su un enum semplice solo quando vuoi proprio la conversione implicita in int, come nelle vecchie costanti flag in stile C.

Valori personalizzati e tipo sottostante

Puoi assegnare numeri espliciti agli enumeratori. Quelli che lasci senza valore continuano a contare dal precedente, il che è comodo per cose come i codici di stato HTTP o i flag a bit:

#include <iostream>
using namespace std;

enum class HttpStatus {
    Ok = 200,
    NotFound = 404,
    ServerError = 500
};

int main() {
    HttpStatus s = HttpStatus::NotFound;
    cout << "Status code: " << static_cast<int>(s) << endl;
    return 0;
}

Ogni enum si basa su un tipo intero, int di default. Puoi fissarlo a un tipo più piccolo quando la dimensione conta, per esempio per memorizzare molti enum in una struttura compatta o per rispettare un formato di trasmissione:

#include <iostream>
#include <cstdint>
using namespace std;

enum class Direction : uint8_t { North, East, South, West };

int main() {
    cout << "size: " << sizeof(Direction) << " byte" << endl;  // 1
    return 0;
}

Scegliere il tipo sottostante garantisce anche l'intervallo in cui devono stare i tuoi valori: un enum uint8_t non può contenere un valore superiore a 255.

Convertire tra enum e int

Un enum class con scope non si converte mai implicitamente, ed è proprio questo il punto. Quando ti serve davvero il numero, per stamparlo, usarlo come indice di un array o leggerlo da un file, usa static_cast. Passare da enum a int è sempre sicuro:

#include <iostream>
using namespace std;

enum class Suit { Hearts, Diamonds, Clubs, Spades };

int main() {
    Suit s = Suit::Clubs;
    int index = static_cast<int>(s);   // 2
    cout << "index: " << index << endl;
    return 0;
}

Riconvertire un int in un enum è la direzione pericolosa. Il cast non controlla che il numero corrisponda a un enumeratore reale: ti restituisce un valore che tecnicamente sta fuori dall'insieme di nomi dell'enum.

Suit s = static_cast<Suit>(2);   // fine - that's Clubs
Suit bad = static_cast<Suit>(99); // compiles, but 99 is not a valid Suit
// using `bad` in a switch or as an array index is a lurking bug

Se l'intero arriva dall'input dell'utente o da un file, controlla tu l'intervallo prima del cast, altrimenti creerai un valore che nessun case gestisce mai: una fonte subdola di comportamento indefinito più avanti.

Usare gli enum con switch

Dato che un enum è "uno fra un insieme fisso", si abbina perfettamente a uno switch. Quando copri ogni enumeratore, molti compilatori ti avvisano se in seguito aggiungi un nuovo valore e ti dimentichi di gestirlo: una sicurezza gratuita che con gli interi grezzi non hai.

#include <iostream>
using namespace std;

enum class TrafficLight { Red, Yellow, Green };

void describe(TrafficLight light) {
    switch (light) {
        case TrafficLight::Red:
            cout << "Stop" << endl;
            break;
        case TrafficLight::Yellow:
            cout << "Slow down" << endl;
            break;
        case TrafficLight::Green:
            cout << "Go" << endl;
            break;
    }
}

int main() {
    describe(TrafficLight::Yellow);
    return 0;
}

Un'insidia: non esiste un modo predefinito per stampare il nome di un enumeratore. cout << TrafficLight::Red non compila per un enum con scope, e anche per un enum semplice stampa il numero, non "Red". Un piccolo switch o una tabella di lookup come quella qui sopra è il modo abituale per trasformare un enum in una stringa leggibile.

Prossimo: Eccezioni

Enum e struct ti permettono di modellare come sono fatti i tuoi dati. Ma i programmi reali devono anche gestire le cose che vanno storte: un file che non si apre, un numero che non si riesce a interpretare, un valore fuori intervallo. Il C++ gestisce questi percorsi di errore con le eccezioni, ed è l'argomento della prossima pagina.