Enum w C++: enum class a zwykły enum

Do czego służy enum

Struktura grupuje kilka powiązanych wartości w jeden obiekt. enum rozwiązuje inny problem: nadaje nazwy małemu, stałemu zestawowi wyborów. Zamiast pamiętać, że 0 oznacza "czerwony", 1 "zielony", a 2 "niebieski", piszesz Color::Red, a kompilator pilnuje, żeby wszystko się zgadzało.

Sięganie po enum zawsze, gdy zmienna może przyjąć tylko jeden z kilku nazwanych stanów (kolor sygnalizacji, kolor karty, status połączenia), sprawia, że kod sam się dokumentuje, a kompilator wyłapuje literówki i brakujące przypadki, których gołe liczby całkowite nigdy by nie wychwyciły.

Deklarowanie enuma

Współczesny C++ ma dwie odmiany. Zacznij od tej, po którą powinno się sięgać niemal zawsze: enum class z zasięgiem. Wymieniasz nazwy, a do każdego enumeratora odwołujesz się przez nazwę enuma i :::

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

Zauważ, że piszesz Color::Green, nigdy samo Green. Same wartości to tylko etykiety: porównujesz je, przypisujesz i przekazujesz dalej, ale rzadko interesuje cię liczba pod spodem. Domyślnie Red to 0, Green to 1, a Blue to 2, licząc od zera.

Zwykły enum a enum class

Starszy enum bez zasięgu (bez słowa kluczowego class) wrzuca swoje nazwy prosto do otaczającego zasięgu i sam konwertuje się na int. Brzmi wygodnie, ale powoduje dwa realne problemy:

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

Ponieważ zwykłe enumeratory to nazwy globalne, dwa enumy mogą się zderzyć tylko dlatego, że mają wspólną etykietę. A ponieważ rozpadają się do int, kompilator chętnie porównuje wartości z zupełnie niepowiązanych enumów. enum class z zasięgiem naprawia oba problemy: nazwy żyją wewnątrz typu, a typ nie zamieni się po cichu w 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;
}

Praktyczna zasada: domyślnie używaj enum class. Po zwykły enum sięgaj tylko wtedy, gdy celowo chcesz niejawnej konwersji na int, na przykład przy starych stałych flag w stylu C.

Własne wartości i typ bazowy

Enumeratorom możesz przypisać jawne liczby. Te, które pominiesz, liczą dalej od poprzedniej wartości, co przydaje się przy kodach statusu HTTP albo flagach bitowych:

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

Każdy enum opiera się na typie całkowitym, domyślnie int. Możesz go przypiąć do mniejszego typu, gdy liczy się rozmiar, na przykład przy przechowywaniu wielu enumów w upakowanej strukturze albo dopasowaniu do formatu przesyłu danych:

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

Wybór typu bazowego gwarantuje też zakres, w którym muszą się zmieścić twoje wartości: enum oparty na uint8_t nie pomieści wartości większej niż 255.

Konwersja między enum a int

enum class z zasięgiem nigdy nie konwertuje się niejawnie i o to właśnie chodzi. Gdy naprawdę potrzebujesz liczby (aby ją wypisać, zaindeksować tablicę albo odczytać z pliku), sięgnij po static_cast. Przejście z enum na int jest zawsze bezpieczne:

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

Zamiana int z powrotem na enum to niebezpieczny kierunek. Rzutowanie nie sprawdza, czy liczba odpowiada prawdziwemu enumeratorowi: zwróci wartość, która technicznie leży poza nazwanym zestawem enuma:

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

Jeśli liczba pochodzi od użytkownika albo z pliku, samodzielnie sprawdź zakres przed rzutowaniem. Inaczej utworzysz wartość, której nie obsługuje żaden case, co jest subtelnym źródłem niezdefiniowanego zachowania w dalszej części programu.

Enumy i switch

Ponieważ enum to "jedna z ustalonego zestawu wartości", idealnie pasuje do switch. Gdy obsłużysz każdy enumerator, wiele kompilatorów ostrzeże cię, jeśli później dodasz nową wartość i zapomnisz ją obsłużyć. To darmowe bezpieczeństwo, którego gołe liczby całkowite nie dają:

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

Jedna pułapka: nie ma wbudowanego sposobu na wypisanie nazwy enumeratora. cout << TrafficLight::Red nie skompiluje się dla enuma z zasięgiem, a nawet dla zwykłego enuma wypisze liczbę, a nie "Red". Mały switch albo tablica odnośników, jak powyżej, to zwykły sposób na zamianę enuma w czytelny napis.

Dalej: wyjątki

Enumy i struktury pozwalają modelować, jak wyglądają twoje dane. Prawdziwe programy muszą jednak radzić sobie też z sytuacjami, gdy coś pójdzie nie tak: plik się nie otworzy, liczby nie da się sparsować, wartość wyjdzie poza zakres. C++ obsługuje takie ścieżki błędów za pomocą wyjątków i o nich jest następna strona.