enumerated type

Üdvözlöm, Ön a enumerated type szó jelentését keresi. A DICTIOUS-ban nem csak a enumerated type szó összes szótári jelentését megtalálod, hanem megismerheted az etimológiáját, a jellemzőit és azt is, hogyan kell a enumerated type szót egyes és többes számban mondani. Minden, amit a enumerated type szóról tudni kell, itt található. A enumerated type szó meghatározása segít abban, hogy pontosabban és helyesebben fogalmazz, amikor beszélsz vagy írsz. Aenumerated type és más szavak definíciójának ismerete gazdagítja a szókincsedet, és több és jobb nyelvi forráshoz juttat.

Főnév

enumerated type (tsz. enumerated types)

  1. (informatika) Az enumerált típus (enum) egy olyan speciális típus C++-ban, amely nevesített konstansokat tartalmaz. Ezt főként akkor használjuk, ha egy változó csak bizonyos fix értékeket vehet fel, például hét napjai, irányok vagy státuszok.



1. Alapvető enum használat

Az enum segítségével egyedi konstansokhoz rendelhetünk numerikus értékeket.

#include <iostream>

enum Napok {Hetfo, Kedd, Szerda, Csutortok, Pentek, Szombat, Vasarnap};

int main() {
    Napok ma = Hetfo;

    if (ma == Hetfo) {
        std::cout << "Ma hétfő van!\n";
    }

    return 0;
}

Hogyan működik?

  • Az enum a Napok nevű típust definiálja.
  • Az enum belsejében lévő nevek (Hetfo, Kedd, stb.) implicit módon egész számokat kapnak (alapértelmezett kezdőérték: 0).
  • Az ma változó csak a Napok típusú értékeket veheti fel.

💡 Az alapértelmezett értékek: - Hetfo = 0 - Kedd = 1 - Szerda = 2 - …

Ha egy konkrét értéket szeretnénk beállítani:

enum Napok {Hetfo = 1, Kedd = 2, Szerda = 3};

Ekkor: - Hetfo = 1 - Kedd = 2 - Szerda = 3



2. enum háttérben egész számokat használ

Az enum értékei egész számokként viselkednek, így akár ki is írhatók:

std::cout << "Hetfo erteke: " << Hetfo << std::endl; // 0
std::cout << "Pentek erteke: " << Pentek << std::endl; // 4

📌 Figyelem! Az enum típusok implicit módon átalakulhatnak egész számokká:

Napok n = Hetfo;
int szam = n;  // szam = 0

De visszafelé már nem mindig biztonságos az átalakítás:

Napok n = static_cast<Napok>(3); // Lehetséges, de veszélyes!

Ezért inkább enum class-t használjunk (erről később).



3. enum értékek testreszabása

Az enum értékeit manuálisan is beállíthatjuk, és azok nem feltétlenül kell növekvő sorrendben legyenek:

enum HibaKod {
    Siker = 0,
    Figyelmeztetes = 100,
    Hiba = 500,
    KritikusHiba = 1000
};

📌 Tipp: Ha a következő értéket nem adjuk meg, akkor automatikusan az előző érték +1 lesz.



4. enum hatókör (Scoped Enum) – enum class

A hagyományos enum-nak van néhány problémája: - Az értékek globálisan elérhetőek (pl. Hetfo “szennyezheti” a névteret). - Az enum automatikusan átalakulhat int-é. - Különböző enum típusok nevei ütközhetnek.

Ezeket a problémákat az enum class oldja meg:

enum class Napok {Hetfo, Kedd, Szerda, Csutortok, Pentek, Szombat, Vasarnap};

int main() {
    Napok ma = Napok::Hetfo;

    if (ma == Napok::Hetfo) {
        std::cout << "Ma hétfő van!\n";
    }

    return 0;
}

📌 Mit változtatott meg az enum class? 1. Nem globálisan elérhető neveket hoz létre, hanem Napok::Hetfo formában kell hivatkozni rájuk. 2. Nem alakítható át automatikusan int-té, így a következő sor hibás lesz: cpp int x = Napok::Hetfo; // Hibás!

Ha mégis szükségünk van az értékére, akkor explicit módon kell konvertálnunk:

int x = static_cast<int>(Napok::Hetfo); // OK

5. enum class és adattípusok

Az enum class lehetővé teszi, hogy az enum mögöttes típusa ne csak int, hanem más is lehessen:

enum class Allapot : unsigned int {
    Kezdes = 1,
    Futas = 2,
    Leallas = 3
};

Itt az enum értékek unsigned int típusúak lesznek, ami memóriában is hatékonyabb lehet.



6. Használat switch-ben

A switch kiválóan működik enum-mal:

#include <iostream>

enum class Szinek {Piros, Zold, Kek};

void szinKiir(Szinek szin) {
    switch (szin) {
        case Szinek::Piros:
            std::cout << "Piros\n";
            break;
        case Szinek::Zold:
            std::cout << "Zöld\n";
            break;
        case Szinek::Kek:
            std::cout << "Kék\n";
            break;
        default:
            std::cout << "Ismeretlen szín\n";
    }
}

int main() {
    Szinek s = Szinek::Zold;
    szinKiir(s);
    return 0;
}

7. enum iterálása

C++ alapból nem támogatja az enum típusok egyszerű iterálását, de segíthetünk rajta:

#include <iostream>

enum class Gyumolcs {Alma, Korte, Szilva, Barack};

int main() {
    for (int i = static_cast<int>(Gyumolcs::Alma); i <= static_cast<int>(Gyumolcs::Barack); ++i) {
        std::cout << "Gyümölcs index: " << i << std::endl;
    }
    return 0;
}

💡 Jobb megoldás: Ha sokat iterálunk, használhatunk std::array-t vagy std::vector-t.



8. Összegzés

Tulajdonság Hagyományos enum enum class
Globális névtérszennyezés Igen Nem
Automatikus int konverzió Igen Nem
Biztonságos típuskezelés Nem Igen
switch támogatás Igen Igen
Iterálás Nem natív módon Nem natív módon

Az enum class az ajánlott verzió, mert típusbiztonságos és jobban olvasható.