Typy wyliczeniowe (ang. enumeration types lub enum) w języku C++ to jeden ze sposobów reprezentowania wartości, które są logicznie powiązane i mają skończoną liczbę możliwych opcji. Typy te pomagają wprowadzać czytelność i zrozumiałość do kodu, zmniejszając ryzyko błędów związanych z używaniem wartości liczbowych zamiast symbolicznych nazw. Użycie typów wyliczeniowych pozwala na łatwiejsze zarządzanie stanami, trybami czy opcjami w aplikacjach, co jest szczególnie przydatne w programowaniu zorientowanym obiektowo. W tej lekcji szczegółowo omówimy, jak tworzyć i używać typów wyliczeniowych, jakie są ich zalety i ograniczenia oraz jakie nowe funkcjonalności zostały wprowadzone w C++11.

Podstawowa składnia typu wyliczeniowego

W C++ typ wyliczeniowy jest deklarowany przy użyciu słowa kluczowego enum, a jego składnia jest prosta. Typ wyliczeniowy definiuje zbiór nazwanych stałych, które reprezentują konkretne wartości liczbowe.

Podstawowy przykład typu wyliczeniowego

enum DzienTygodnia {
    Poniedzialek,
    Wtorek,
    Sroda,
    Czwartek,
    Piatek,
    Sobota,
    Niedziela
};

int main() {
    DzienTygodnia dzien = Poniedzialek;
    if (dzien == Poniedzialek) {
        std::cout << "Dzisiaj jest poniedziałek." << std::endl;
    }
    return 0;
}

W powyższym przykładzie DzienTygodnia jest typem wyliczeniowym, który definiuje dni tygodnia. Zamiast używać liczb całkowitych, możemy korzystać z nazw, co poprawia czytelność i zrozumiałość kodu.

Domyślne wartości typów wyliczeniowych

Każda nazwa w typie wyliczeniowym jest automatycznie przypisywana do wartości całkowitej, zaczynając od 0. Można jednak przypisywać niestandardowe wartości, jeśli istnieje taka potrzeba.

Przykład przypisywania wartości

enum Kolor {
    Czerwony = 1,
    Zielony = 3,
    Niebieski = 5
};

int main() {
    Kolor kolor = Zielony;
    std::cout << "Wartość Zielonego: " << kolor << std::endl;
    return 0;
}

W tym przykładzie Czerwony ma wartość 1, Zielony ma wartość 3, a Niebieski ma wartość 5. Możemy w ten sposób kontrolować wartości, które są przypisane do każdej stałej.

Typy wyliczeniowe w C++11 i późniejszych

Standard C++11 wprowadził nowe funkcjonalności związane z typami wyliczeniowymi, takie jak wyliczenia silnie typowane (ang. strongly-typed enums), które zwiększają bezpieczeństwo typów i eliminują niejednoznaczności związane z rzutowaniem typów.

Wyliczenia silnie typowane

W wyliczeniach silnie typowanych używa się słowa kluczowego enum class, co zapobiega niezamierzonemu rzutowaniu typów wyliczeniowych na liczby całkowite.

Przykład wyliczenia silnie typowanego

enum class Dzien {
    Poniedzialek,
    Wtorek,
    Sroda,
    Czwartek,
    Piatek,
    Sobota,
    Niedziela
};

int main() {
    Dzien dzien = Dzien::Poniedzialek;
    if (dzien == Dzien::Poniedzialek) {
        std::cout << "To jest silnie typowany poniedziałek." << std::endl;
    }
    return 0;
}

W tym przykładzie Dzien jest wyliczeniem silnie typowanym, co oznacza, że nie można go porównać bezpośrednio z wartością liczbową bez jawnego rzutowania. Taki sposób deklarowania typów wyliczeniowych jest bezpieczniejszy i bardziej zgodny z zasadami programowania zorientowanego obiektowo.

Rzutowanie typów wyliczeniowych

W przypadku tradycyjnych typów wyliczeniowych (nie silnie typowanych) możliwe jest niejawne rzutowanie na typ int. Jednakże w przypadku wyliczeń silnie typowanych musimy używać jawnego rzutowania.

Przykład rzutowania typów wyliczeniowych

enum class Stan {
    Start,
    Stop,
    Pauza
};

int main() {
    Stan stan = Stan::Start;
    int wartosc = static_cast<int>(stan); // Jawne rzutowanie
    std::cout << "Wartość stanu: " << wartosc << std::endl;
    return 0;
}

W tym przykładzie używamy static_cast<int>, aby jawnie rzutować typ Stan na wartość całkowitą. Taka konstrukcja zapobiega przypadkowemu rzutowaniu, co zwiększa bezpieczeństwo kodu.

Zastosowanie typów wyliczeniowych

Typy wyliczeniowe są przydatne w wielu sytuacjach, takich jak zarządzanie stanami maszyny stanów, wybór trybów pracy aplikacji czy reprezentowanie zestawu możliwych opcji. Dzięki użyciu typów wyliczeniowych kod staje się bardziej czytelny i mniej podatny na błędy.

Przykład użycia w maszynie stanów

enum class StanMaszyny {
    Gotowy,
    Pracuje,
    Zakonczony,
    Awaria
};

void sprawdzStan(StanMaszyny stan) {
    switch (stan) {
        case StanMaszyny::Gotowy:
            std::cout << "Maszyna jest gotowa." << std::endl;
            break;
        case StanMaszyny::Pracuje:
            std::cout << "Maszyna pracuje." << std::endl;
            break;
        case StanMaszyny::Zakonczony:
            std::cout << "Proces zakończony." << std::endl;
            break;
        case StanMaszyny::Awaria:
            std::cout << "Wystąpiła awaria!" << std::endl;
            break;
    }
}

int main() {
    StanMaszyny stan = StanMaszyny::Pracuje;
    sprawdzStan(stan);
    return 0;
}

W powyższym przykładzie typ wyliczeniowy StanMaszyny jest używany do zarządzania stanami maszyny. Dzięki switch case kod jest bardziej czytelny i łatwy w utrzymaniu.

Typy wyliczeniowe a zasięg nazw

Tradycyjne typy wyliczeniowe mają zasięg globalny, co może prowadzić do konfliktów nazw. Wprowadzenie wyliczeń silnie typowanych rozwiązuje ten problem, ponieważ nazwy są zagnieżdżone w przestrzeni nazw typu wyliczeniowego.

Porównanie tradycyjnych i silnie typowanych typów wyliczeniowych

// Tradycyjny typ wyliczeniowy
enum Kolor {
    Czerwony,
    Zielony,
    Niebieski
};

// Silnie typowany typ wyliczeniowy
enum class NowyKolor {
    Czerwony,
    Zielony,
    Niebieski
};

int main() {
    Kolor kolor = Czerwony; // Tradycyjny typ wyliczeniowy
    NowyKolor nowyKolor = NowyKolor::Czerwony; // Silnie typowany typ wyliczeniowy
    return 0;
}

Tradycyjny typ Kolor ma nazwy w globalnym zasięgu, co może prowadzić do konfliktów, podczas gdy NowyKolor wymaga użycia prefiksu NowyKolor::, co eliminuje te problemy.

Podsumowanie

Typy wyliczeniowe w C++ to potężne narzędzie, które pozwala na definiowanie zestawów wartości symbolicznych, co zwiększa czytelność i bezpieczeństwo kodu. W tej lekcji nauczyłeś się, jak tworzyć i używać zarówno tradycyjnych, jak i silnie typowanych typów wyliczeniowych, jakie są ich zalety oraz jak rzutować te typy. Poznałeś także zastosowania typów wyliczeniowych w praktyce, takie jak maszyny stanów i zarządzanie trybami pracy. Dzięki zrozumieniu typów wyliczeniowych będziesz mógł pisać bardziej efektywny i bezpieczny kod w C++.

Następny temat ==> Inne przydatne typy danych