C++ Academy · Lektion

Scoped enum class

Typsichere Enumerationen

Scoped enum class ist eine kostenlose C++ Academy-Lektion auf CoddyKit. Dies ist Lektion 1 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des C++ Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der C++ Academy-Kurs umfasst insgesamt 4 Lektionen.

Unscoped-Enums geben Namen frei

Ein klassisches C-enum legt seine Namen im umgebenden Gültigkeitsbereich ab und wird stillschweigend in int umgewandelt. Dadurch werden Namenskonflikte und versehentliche Vergleiche begünstigt.

enum class löst beide Probleme.
Die Werte sind bereichsbezogen und typsicher.

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

Ein Scoped Enum deklarieren

Fügen Sie das Schlüsselwort class (oder struct) hinzu, um eine Scoped Enumeration zu erstellen. Nun müssen Sie jeden Wert mit dem Namen des Enums qualifizieren.

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

Keine implizite Konvertierung

Ein Scoped Enum wird nicht implizit in ein int umgewandelt. Dadurch werden Fehler verhindert, bei denen ein Enum versehentlich in einer arithmetischen Berechnung verwendet wird.

Um die Zahl zu erhalten, müssen Sie explizit casten.

#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
}

Zugrunde liegender Typ

Standardmäßig ist der zugrunde liegende Typ int. Sie können jedoch einen kleineren oder bestimmten Ganzzahltyp auswählen, um Speicherplatz zu sparen oder ein Protokoll abzubilden.

#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";
}

Eigene Werte

Sie können Enumeratoren explizite Werte zuweisen. Auf einen expliziten Wert folgende Enumeratoren zählen von diesem Wert aus weiter.

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

Ein Enum in switch verwenden

Enums kommen in switch-Anweisungen besonders gut zur Geltung. Wenn Sie jeden Fall aufführen, wird die Absicht deutlich und der Compiler kann vor fehlenden Fällen warnen.

#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"; }

Enums als Funktionsargumente

Die Übergabe eines Scoped Enums vermittelt die Absicht deutlich besser als die Übergabe eines einfachen int oder bool. Der Compiler stellt sicher, dass nur gültige Enum-Werte verwendet werden.

#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); }

Enum-Werte vergleichen

Scoped Enums unterstützen == und != direkt. Auch relationale Operatoren (<, >) funktionieren, da die Werte geordnet sind.

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

Konzeptionell iterieren

Enums können nicht automatisch durchlaufen werden. Ein übliches Muster besteht jedoch darin, über die zugrunde liegenden Ganzzahlen zu casten. Verwenden Sie einen Sentinel wie Count, um den Bereich zu erkennen.

#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";
}

Warum Typsicherheit wichtig ist

Zwei voneinander unabhängige Scoped Enums können niemals versehentlich vermischt werden, selbst wenn beide einen Wert namens None besitzen. Der Compiler behandelt sie als unterschiedliche Typen.

#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";
}

Wann Unscoped-Enums verwendet werden

Unscoped-Enums kommen weiterhin in älteren APIs und in Code mit Bit-Flags vor, bei dem die implizite Konvertierung in int praktisch ist. Für neuen Code sollten Sie enum class bevorzugen, sofern kein besonderer Grund dagegenspricht.

Kurzer Test

Testen Sie Ihr Verständnis von Scoped Enums.

Zusammenfassung

Sie haben Scoped Enums kennengelernt:

enum class begrenzt den Gültigkeitsbereich der Werte und verhindert die implizite Konvertierung in int.
Verwenden Sie static_cast<int>, um die Zahl auszulesen.
Wählen Sie mit : type einen zugrunde liegenden Typ.
Bevorzugen Sie enum class für typsicheren, selbstdokumentierenden Code.

Häufig gestellte Fragen

Ist die Lektion „Scoped enum class“ kostenlos?

Ja — der vollständige Text von „Scoped enum class“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des C++ Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der C++ Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Scoped enum class“?

Typsichere Enumerationen Du übst C++ Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um C++ Academy zu starten?

Keine Vorkenntnisse erforderlich. C++ Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 1 von 4.

Wie lange dauert die Lektion „Scoped enum class“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser C++ Academy-Lektion Code schreiben und ausführen?

Ja. Jede C++ Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu C++ Academy