Enumerations

Ein enumerated type ist ein eigenständiger Typ , dessen Wert ein Wert seines underlying type ist (siehe unten), der die Werte explizit benannter Konstanten ( enumeration constants ) umfasst.

Syntax

Aufzählungstyp wird mit dem folgenden Aufzählungsspezifizierer als Typ-Spezifizierer in der Deklarationsgrammatik deklariert:

wobei enumerator-list eine durch Kommas getrennte Liste (mit nachfolgendem Komma erlaubt) (seit C99) von enumerator ist, von denen jeder die folgende Form hat:

wo

Wie bei struct oder union kann eine Deklaration, die einen Aufzählungstyp und eine oder mehrere Aufzählungskonstanten einführt, auch ein oder mehrere Objekte dieses Typs oder davon abgeleiteter Typen deklarieren.

enum color { RED, GREEN, BLUE } c = RED, *cp = &c;
// führt den Typ enum color ein
// die Integer-Konstanten RED, GREEN, BLUE
// das Objekt c vom Typ enum color
// das Objekt cp vom Typ Zeiger auf enum color

Erklärung

Jede enumeration-constant , die im Rumpf einer Aufzählungsspezifikation erscheint, wird zu einer ganzzahligen Konstante mit dem Typ int (bis C23) im umschließenden Gültigkeitsbereich und kann überall verwendet werden, wo ganzzahlige Konstanten erforderlich sind (z.B. als case-Label oder als Nicht-VLA-Arraygröße).

enum color { RED, GREEN, BLUE } r = RED;
switch(r)
{
case RED:
    puts("rot");
    break;
case GREEN:
    puts("grün");
    break;
case BLUE:
    puts("blau");
    break;
}

Wenn enumeration-constant von = constant-expression gefolgt wird, ist ihr Wert der Wert dieses konstanten Ausdrucks. Wenn enumeration-constant nicht von = constant-expression gefolgt wird, ist ihr Wert um eins größer als der Wert des vorherigen Enumerators in derselben Enumeration. Der Wert des ersten Enumerators (falls er nicht = constant-expression verwendet) ist null.

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 Bezeichner selbst, falls verwendet, wird zum Namen des Aufzählungstyps im Namensraum der Tags und erfordert die Verwendung des Schlüsselworts enum (sofern nicht mittels typedef in den gewöhnlichen Namensraum verschoben).

enum color { RED, GREEN, BLUE };
enum color r = RED; // OK
// color x = GREEN; // Fehler: color ist nicht im gewöhnlichen Namensraum
typedef enum color color_t;
color_t x = GREEN; // OK

Jeder Aufzählungstyp ohne festgelegten zugrundeliegenden Typ (seit C23) ist kompatibel mit einem der folgenden Typen: char , einem vorzeichenbehafteten Ganzzahltyp oder einem vorzeichenlosen Ganzzahltyp (ausgenommen bool und die bitgenauen Ganzzahltypen) (seit C23) . Es ist implementierungsdefiniert, welcher Typ mit einem bestimmten Aufzählungstyp kompatibel ist, aber unabhängig davon muss er in der Lage sein, alle Enumeratorwerte dieser Aufzählung darzustellen. Für alle Aufzählungen mit einem festgelegten zugrundeliegenden Typ ist der Aufzählungstyp mit dem zugrundeliegenden Typ der Aufzählung kompatibel. (seit C23)

Aufzählungstypen sind ganzzahlige Typen und können daher überall dort verwendet werden, wo andere ganzzahlige Typen verwendet werden können, einschließlich bei impliziten Konvertierungen und arithmetischen Operatoren .

enum { ONE = 1, TWO } e;
long n = ONE; // Höherstufung
double d = ONE; // Konvertierung
e = 1.2; // Konvertierung, e ist jetzt ONE
e = e + 1; // e ist jetzt TWO

Hinweise

Im Gegensatz zu struct oder union gibt es in C keine vorwärtsdeklarierten Enums:

enum Color; // Fehler: keine Vorwärtsdeklarationen für Enums in C
enum Color { RED, GREEN, BLUE };

Aufzählungen ermöglichen die Deklaration benannter Konstanten auf eine bequemere und strukturiertere Weise als #define ; sie sind im Debugger sichtbar, befolgen Bereichsregeln und nehmen am Typsystem teil.

#define TEN 10
struct S { int x : TEN; }; // OK

oder

enum { TEN = 10 };
struct S { int x : TEN; }; // ebenfalls OK

Seit C23 kann constexpr für denselben Zweck verwendet werden:

constexpr int TEN = 10;
struct S { int x : TEN; }; // ebenfalls OK

Darüber hinaus, da ein struct oder eine union in C keinen eigenen Gültigkeitsbereich etabliert, können ein Aufzählungstyp und seine Aufzählungskonstanten in der Memberspezifikation des ersteren eingeführt werden, und ihr Gültigkeitsbereich ist derselbe wie der des ersteren, danach.

struct Element
{
    int z;
    enum State { SOLID, LIQUID, GAS, PLASMA } state;
} oxygen = { 8, GAS };
// Der Typ enum State und seine Aufzählungskonstanten bleiben hier sichtbar, z.B.
void foo(void)
{
    enum State e = LIQUID; // OK
    printf("%d %d %d ", e, oxygen.state, PLASMA); // gibt 1 2 3 aus
}

Beispiel

#include <stdio.h>
int main(void)
{
    enum TV { FOX = 11, CNN = 25, ESPN = 15, HBO = 22, MAX = 30, NBC = 32 };
    printf("List of cable stations:\n");
    printf(" FOX: \t%2d\n", FOX);
    printf(" HBO: \t%2d\n", HBO);
    printf(" MAX: \t%2d\n", MAX);
}

List of cable stations:
 FOX:   11
 HBO:   22
 MAX:   30

Referenzen

Schlüsselwörter

enum

Siehe auch