C++ Academy · Lezione

Classe enum con ambito

Enumerazioni con sicurezza dei tipi

Classe enum con ambito è una lezione C++ Academy gratuita su CoddyKit. Questa è la lezione 1 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento C++ Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso C++ Academy include 4 lezioni in totale.

Le enumerazioni semplici espongono i nomi

Una enum classica in stile C inserisce i propri nomi nell'ambito circostante e si converte implicitamente in int. Questo facilita i conflitti tra nomi e i confronti accidentali.

enum class risolve entrambi i problemi.
I valori hanno un ambito e sono fortemente tipizzati.

#include <iostream>
enum Color { Red, Green, Blue };
int main() {
    Color c = Green;
    int x = c; // implicit conversion to int
    std::cout << x << "\n";
}

Dichiarare un'enumerazione con ambito

Aggiunga la parola chiave class (o struct) per creare un'enumerazione con ambito. Ora deve qualificare ogni valore con il nome dell'enumerazione.

#include <iostream>
enum class Color { Red, Green, Blue };
int main() {
    Color c = Color::Green;
    if (c == Color::Green) std::cout << "green\n";
}

Nessuna conversione implicita

Un'enumerazione con ambito non viene convertita implicitamente in un int. Questo previene gli errori in cui un'enumerazione viene usata accidentalmente in un'operazione aritmetica.

Per ottenere il numero deve eseguire un cast esplicito.

#include <iostream>
enum class Color { Red, Green, Blue };
int main() {
    Color c = Color::Blue;
    int n = static_cast<int>(c); // explicit
    std::cout << n << "\n"; // prints 2
}

Tipo sottostante

Per impostazione predefinita, il tipo sottostante è int, ma è possibile scegliere un tipo intero più piccolo o specifico per risparmiare spazio o adattarsi a un protocollo.

#include <iostream>
#include <cstdint>
enum class Status : std::uint8_t { Ok = 0, Warn = 1, Error = 2 };
int main() {
    Status s = Status::Warn;
    std::cout << static_cast<int>(s) << "\n";
}

Valori personalizzati

È possibile assegnare valori espliciti agli enumeratori. I valori che seguono quello esplicito continuano a essere incrementati a partire da esso.

#include <iostream>
enum class Http { Ok = 200, NotFound = 404, ServerError = 500 };
int main() {
    Http h = Http::NotFound;
    std::cout << static_cast<int>(h) << "\n";
}

Usare un'enumerazione in switch

Le enumerazioni sono particolarmente utili nelle istruzioni switch. Elencare ogni caso rende chiaro l'intento e consente al compilatore di segnalare i casi mancanti.

#include <iostream>
enum class Dir { North, East, South, West };
const char* name(Dir d) {
    switch (d) {
        case Dir::North: return "N";
        case Dir::East:  return "E";
        case Dir::South: return "S";
        case Dir::West:  return "W";
    }
    return "?";
}
int main() { std::cout << name(Dir::East) << "\n"; }

Enumerazioni come argomenti di funzione

Passare un'enumerazione con ambito comunica l'intento molto meglio che passare un semplice int o bool. Il compilatore impone l'uso esclusivo di valori validi per l'enumerazione.

#include <iostream>
enum class Align { Left, Center, Right };
void render(const char* text, Align a) {
    std::cout << text << " aligned " << static_cast<int>(a) << "\n";
}
int main() { render("Hi", Align::Center); }

Confrontare i valori delle enumerazioni

Le enumerazioni con ambito supportano direttamente == e !=. Funzionano anche gli operatori relazionali (<, >), perché i valori sono ordinati.

#include <iostream>
enum class Level { Low, Medium, High };
int main() {
    Level l = Level::High;
    std::cout << (l > Level::Low ? "above low\n" : "low\n");
}

Iterare concettualmente

Le enumerazioni non sono iterabili automaticamente, ma un modello comune consiste nell'eseguire un cast passando per gli interi sottostanti. Mantenga un valore sentinella come Count per conoscere l'intervallo.

#include <iostream>
enum class Coin { Penny, Nickel, Dime, Count };
int main() {
    for (int i = 0; i < static_cast<int>(Coin::Count); ++i)
        std::cout << i << " ";
    std::cout << "\n";
}

Perché la sicurezza dei tipi è importante

Due enumerazioni con ambito non correlate non possono mai essere mescolate accidentalmente, anche se entrambe hanno un valore chiamato None. Il compilatore le considera tipi distinti.

#include <iostream>
enum class Fruit { None, Apple };
enum class Tool  { None, Hammer };
int main() {
    Fruit f = Fruit::None;
    // Tool t = f; // would NOT compile
    std::cout << (f == Fruit::None) << "\n";
}

Quando usare le enumerazioni semplici

Le enumerazioni semplici sono ancora presenti nelle API legacy e nel codice con flag di bit, dove la conversione implicita in int è comoda. Per il nuovo codice, preferisca enum class, salvo un motivo specifico.

Verifica rapida

Verifichi la propria comprensione delle enumerazioni con ambito.

Riepilogo

Ha imparato a usare le enumerazioni con ambito:

enum class assegna un ambito ai valori e impedisce la conversione implicita in int.
Usi static_cast<int> per leggere il numero.
Scelga un tipo sottostante con : type.
Preferisca enum class per ottenere codice sicuro rispetto ai tipi e autoesplicativo.

Domande Frequenti

La lezione «Classe enum con ambito» è gratuita?

Sì — il testo completo di «Classe enum con ambito» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso C++ Academy, passa a CoddyKit PRO. Il corso C++ Academy include 4 lezioni in totale.

Cosa imparerò in «Classe enum con ambito»?

Enumerazioni con sicurezza dei tipi Eserciti C++ Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare C++ Academy?

Non è richiesta alcuna esperienza precedente. C++ Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 1 di 4.

Quanto tempo richiede la lezione «Classe enum con ambito»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione C++ Academy?

Sì. Ogni lezione C++ Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a C++ Academy