Enumeration declaration

Eine Enumeration ist ein eigener Typ, dessen Wert auf einen Wertebereich beschränkt ist (siehe unten für Details), der mehrere explizit benannte Konstanten (" Enumeratoren ") enthalten kann.

Die Werte der Konstanten sind Werte eines ganzzahligen Typs, der als der zugrundeliegende Typ der Aufzählung bekannt ist. Eine Aufzählung hat dieselbe Größe , Wertdarstellung und Ausrichtungsanforderungen wie ihr zugrundeliegender Typ. Darüber hinaus hat jeder Wert einer Aufzählung dieselbe Darstellung wie der entsprechende Wert des zugrundeliegenden Typs.

Eine Aufzählung wird mit der folgenden Syntax (neu)deklariert:

Es gibt zwei verschiedene Arten von Aufzählungen: unbegrenzte Aufzählung (deklariert mit dem enum-key enum ) und begrenzte Aufzählung (deklariert mit dem enum-key enum class oder enum struct ).

Unbegrenzte Aufzählungen

Jeder Enumerator wird zu einer benannten Konstante des Enumerationstyps (d.h. name ), sichtbar im umschließenden Gültigkeitsbereich, und kann verwendet werden, wann immer Konstanten erforderlich sind.

enum Color { red, green, blue };
Color r = red;
switch(r)
{
    case red  : std::cout << "rot\n";    break;
    case green: std::cout << "grün\n";  break;
    case blue : std::cout << "blau\n";   break;
}

Jeder Enumerator ist mit einem Wert des zugrundeliegenden Typs assoziiert. Wenn = in einer enumerator-list angegeben werden, werden die Werte der Enumeratoren durch die zugehörigen constant-expression s definiert. Wenn der erste Enumerator kein = besitzt, ist der assoziierte Wert null. Für jeden anderen Enumerator, dessen Definition kein = aufweist, ist der assoziierte Wert der Wert des vorherigen Enumerators plus eins.

enum Foo { a, b, c = 10, d, e = 1, f, g = f + c };
//a = 0, b = 1, c = 10, d = 11, e = 1, f = 2, g = 12

Der Name einer unbegrenzten Enumeration kann weggelassen werden: Eine solche Deklaration führt nur die Enumeratoren in den einschließenden Gültigkeitsbereich ein:

enum { a, b, c = 0, d = a + 2 }; // definiert a = 0, b = 1, c = 0, d = 2

Wenn eine unbegrenzte Aufzählung ein Klassenmitglied ist, können ihre Enumeratoren mit den Klassenmitglied-Zugriffsoperatoren . und -> zugegriffen werden:

struct X
{
    enum direction { left = 'l', right = 'r' };
};
X x;
X* p = &x;
int a = X::direction::left; // nur in C++11 und später erlaubt
int b = X::left;
int c = x.left;
int d = p->left;

struct S
{
    enum E1 : int {};
    enum E1 : int {}; // Fehler: Neudeklaration der Aufzählung,
                      // NICHT geparst als Bitfeld der Länge Null vom Typ enum E1
};
enum E2 { e1 };
void f()
{
    false ? new enum E2 : int(); // OK: 'int' wird NICHT als zugrundeliegender Typ geparst
}

Aufzählungsname für Verknüpfungszwecke

Eine unbenannte Enumeration, die keinen typedef-Namen für Verknüpfungszwecke besitzt und einen Enumerator hat, wird für Verknüpfungszwecke durch ihren zugrundeliegenden Typ und ihren ersten Enumerator bezeichnet; eine solche Enumeration wird als einen Enumerator als Namen für Verknüpfungszwecke besitzend bezeichnet.

Bereichsbezogene Aufzählungen

#include <iostream>
int main()
{
    enum class Color { red, green = 20, blue };
    Color r = Color::blue;
    switch(r)
    {
        case Color::red  : std::cout << "red\n";   break;
        case Color::green: std::cout << "green\n"; break;
        case Color::blue : std::cout << "blue\n";  break;
    }
    // int n = r; // Fehler: keine implizite Konvertierung von Bereichs-Enum zu int
    int n = static_cast<int>(r); // OK, n = 21
    std::cout << n << '\n'; // gibt 21 aus
}

enum byte : unsigned char {}; // byte is a new integer type; see also std::byte (C++17)
byte b{42};        // OK as of C++17 (direct-list-initialization)
byte c = {42};     // error
byte d = byte{42}; // OK as of C++17; same value as b
byte e{-1};        // error
struct A { byte b; };
A a1 = {{42}};     // error (copy-list-initialization of a constructor parameter)
A a2 = {byte{42}}; // OK as of C++17
void f(byte);
f({42}); // error (copy-list-initialization of a function parameter)
enum class Handle : std::uint32_t { Invalid = 0 };
Handle h{42}; // OK as of C++17

enum E { x };
void f()
{
    int E;
    using enum E; // OK
}
using F = E;
using enum F; // OK
template<class T>
using EE = T;
void g()
{
    using enum EE<E>; // OK
}

enum class fruit { orange, apple };
struct S
{
    using enum fruit; // OK: führt orange und apple in S ein
};
void f()
{
    S s;
    s.orange;  // OK: benennt fruit::orange
    S::orange; // OK: benennt fruit::orange
}

enum class fruit { orange, apple };
enum class color { red, orange };
void f()
{
    using enum fruit;    // OK
    // using enum color; // Fehler: color::orange und fruit::orange stehen im Konflikt
}

Hinweise

Werte von Aufzählungstypen ohne Gültigkeitsbereich können zu integralen Typen heraufgestuft oder konvertiert werden:

enum color { red, yellow, green = 20, blue };
color col = red;
int n = blue; // n == 21

Werte von Integer-, Gleitkomma- und Aufzählungstypen können durch Verwendung von static_cast in jeden Aufzählungstyp konvertiert werden. Beachten Sie, dass der Wert nach einer solchen Konvertierung nicht notwendigerweise einem der für die Aufzählung definierten benannten Enumeratoren entsprechen muss:

enum access_t { read = 1, write = 2, exec = 4 }; // Enumeratoren: 1, 2, 4 Bereich: 0..7
access_t rwe = static_cast<access_t>(7);
assert((rwe & read) && (rwe & write) && (rwe & exec));
access_t x = static_cast<access_t>(8.0); // Undefiniertes Verhalten seit CWG 1766
access_t y = static_cast<access_t>(8);   // Undefiniertes Verhalten seit CWG 1766
enum foo { a = 0, b = UINT_MAX }; // Bereich: [0, UINT_MAX]
foo x = foo(-1); // Undefiniertes Verhalten seit CWG 1766,
                 // selbst wenn der zugrundeliegende Typ von foo unsigned int ist

Schlüsselwörter

enum , struct , class , using

Beispiel

#include <cstdint>
#include <iostream>
// Enumeration, die 16 Bits belegt
enum smallenum: std::int16_t
{
    a,
    b,
    c
};
// Farbe kann rot (Wert 0), gelb (Wert 1), grün (Wert 20) oder blau (Wert 21) sein
enum color
{
    red,
    yellow,
    green = 20,
    blue
};
// Höhe kann altitude::high oder altitude::low sein
enum class altitude: char
{
    high = 'h',
    low = 'l', // Nachgestelltes Komma nur erlaubt nach CWG 518
}; 
// Die Konstante d ist 0, die Konstante e ist 1, die Konstante f ist 3
enum
{
    d,
    e,
    f = e + 2
};
// Aufzählungstypen (sowohl scoped als auch unscoped) können überladene Operatoren haben
std::ostream& operator<<(std::ostream& os, color c)
{
    switch(c)
    {
        case red   : os << "red";    break;
        case yellow: os << "yellow"; break;
        case green : os << "green";  break;
        case blue  : os << "blue";   break;
        default    : os.setstate(std::ios_base::failbit);
    }
    return os;
}
std::ostream& operator<<(std::ostream& os, altitude al)
{
    return os << static_cast<char>(al);
}
// Der scoped enum (C++11) kann in früheren C++-Revisionen teilweise emuliert werden:
enum struct E11 { x, y }; // seit C++11
struct E98 { enum { x, y }; }; // OK in pre-C++11
namespace N98 { enum { x, y }; } // OK in pre-C++11
struct S98 { static const int x = 0, y = 1; }; // OK in pre-C++11
void emu()
{
    std::cout << (static_cast<int>(E11::y) + E98::y + N98::y + S98::y) << '\n'; // 4
}
namespace cxx20
{
    enum class long_long_long_name { x, y };
    void using_enum_demo()
    {
        std::cout << "C++20 `using enum`: __cpp_using_enum == ";
        switch (auto rnd = []{return long_long_long_name::x;}; rnd())
        {
#if defined(__cpp_using_enum)
            using enum long_long_long_name;
            case x: std::cout << __cpp_using_enum << "; x\n"; break;
            case y: std::cout << __cpp_using_enum << "; y\n"; break;
#else
            case long_long_long_name::x: std::cout << "?; x\n"; break;
            case long_long_long_name::y: std::cout << "?; y\n"; break;
#endif
        }
    }
}
int main()
{
    color col = red;
    altitude a;
    a = altitude::low;
    std::cout << "col = " << col << '\n'
              << "a = "   << a   << '\n'
              << "f = "   << f   << '\n';
    cxx20::using_enum_demo();
}

col = rot
a = l
f = 3
C++20 `using enum`: __cpp_using_enum == 201907; x

Fehlerberichte

Die folgenden verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

Referenzen

Siehe auch