Ausführbare C-Docs: Enums

Q: Wie definiert man ein enum in C?

enum Color { RED, GREEN, BLUE }; definiert einen Typ, dessen Werte die drei benannten Konstanten sind. Standardmäßig werden sie ab 0 nummeriert, RED ist also 0, GREEN ist 1 und BLUE ist 2. Deklariere eine Variable mit enum Color c = GREEN; oder füge ein typedef hinzu, damit du nur Color c schreiben kannst.

Q: Kann man einem enum in C bestimmte Werte zuweisen?

Ja: enum Status { OK = 200, NOT_FOUND = 404, ERROR = 500 };. Du kannst einige setzen und die anderen folgen lassen - jeder Name ohne expliziten Wert zählt vom vorherigen weiter, enum { A = 10, B, C }; ergibt also B = 11 und C = 12.

Q: Wie groß ist ein enum in C?

Implementierungsabhängig, in der Praxis aber sizeof(int) - 4 Bytes auf den meisten Systemen. Der Compiler wählt einen Ganzzahltyp, der jeden Aufzählungswert fassen kann. Nimm keine bestimmte Größe an, wenn du eine Binärdatei oder ein Netzpaket aufbaust; benutze dort einen Typ fester Breite aus .

Code voller nackter Zahlen ist Code, den niemand lesen kann. if (state == 2) sagt dir nichts; if (state == STATE_RUNNING) sagt dir alles. Ein enum ist Cs Weg, einer kleinen, festen Menge von Ganzzahlen ordentliche Namen zu geben - und anders als ein Haufen #defines kommen sie zu einem Typ gruppiert, den der Compiler kennt.

Ein Enum definieren

Die Deklaration benennt ein Tag und listet die Aufzählungswerte in geschweiften Klammern:

#include <stdio.h>

enum Color {
    RED,
    GREEN,
    BLUE
};

int main(void) {
    enum Color favorite = GREEN;

    printf("Lieblingsfarbe = %d\n", favorite);
    printf("RED=%d GREEN=%d BLUE=%d\n", RED, GREEN, BLUE);
    return 0;
}

Zwei Dinge fallen sofort auf. Erstens beginnt die Nummerierung bei 0 und steigt um eins, RED ist also 0, GREEN ist 1, BLUE ist 2. Zweitens sind die Namen der Aufzählungswerte überall im umgebenden Gültigkeitsbereich sichtbar - du schreibst GREEN, nicht Color.GREEN. Sie leben im selben Namensraum wie deine Variablen, weshalb C-Code sie konventionell GROSS schreibt oder ihnen den Typ voranstellt (COLOR_RED), um Kollisionen zu vermeiden.

Ein Enum auszugeben geht mit %d, denn ein Aufzählungswert ist ein Ganzzahlwert.

Explizite Werte

Weise einem beliebigen Aufzählungswert eine explizite Konstante zu, und die folgenden zählen von dort weiter:

#include <stdio.h>

enum HttpStatus {
    HTTP_OK        = 200,
    HTTP_CREATED   = 201,
    HTTP_NOT_FOUND = 404,
    HTTP_ERROR     = 500
};

enum Level {
    LOW = 10,
    MEDIUM,          /* 11 */
    HIGH,            /* 12 */
    CRITICAL = 100,
    EXTREME          /* 101 */
};

int main(void) {
    printf("%d %d %d %d\n", HTTP_OK, HTTP_CREATED, HTTP_NOT_FOUND, HTTP_ERROR);
    printf("%d %d %d %d %d\n", LOW, MEDIUM, HIGH, CRITICAL, EXTREME);
    return 0;
}

Werte müssen weder eindeutig noch geordnet sein - zwei Aufzählungswerte dürfen sich eine Zahl teilen, was gelegentlich für Aliase nützlich ist (COLOR_DEFAULT = COLOR_BLACK). Sie müssen Ganzzahlkonstanten zur Übersetzungszeit sein, du kannst also keinen aus einer Variablen berechnen.

Ein verbreitetes Idiom nutzt das, um die Anzahl festzuhalten:

enum Suit {
    CLUBS, DIAMONDS, HEARTS, SPADES,
    SUIT_COUNT           /* automatisch 4 - bleibt korrekt, wenn du eine Farbe ergänzt */
};

SUIT_COUNT ist keine echte Farbe; es ist ihre Anzahl, die die automatische Nummerierung kostenlos pflegt. Schleifen und Arraygrößen können sie benutzen und veralten nie.

typedef enum

Wie bei Strukturen ist der vollständige Typname in C enum Color, und ein typedef lässt das Schlüsselwort weg:

#include <stdio.h>

typedef enum Direction {
    DIR_NORTH,
    DIR_EAST,
    DIR_SOUTH,
    DIR_WEST,
    DIR_COUNT
} Direction;

int main(void) {
    const int dx[DIR_COUNT] = {0, 1, 0, -1};
    const int dy[DIR_COUNT] = {-1, 0, 1, 0};

    int x = 0, y = 0;
    Direction path[] = {DIR_EAST, DIR_EAST, DIR_SOUTH, DIR_WEST};

    for (size_t i = 0; i < sizeof path / sizeof path[0]; i++) {
        x += dx[path[i]];
        y += dy[path[i]];
    }

    printf("geendet bei (%d, %d)\n", x, y);
    return 0;
}

Weil Aufzählungswerte gewöhnliche Ganzzahlen ab 0 sind, dienen sie zugleich als Array-Indizes - dx[DIR_EAST] funktioniert ohne jede Umwandlung. Das ist die mit Abstand nützlichste Eigenschaft eines nullbasierten Enums.

Enums in einem switch

Ein Enum mit einem switch zu paaren ist die Stelle, an der sich der Typ bezahlt macht. Kompiliere mit -Wall, und der Compiler sagt dir, wenn du einen Fall vergisst.

#include <stdio.h>

typedef enum {
    STATE_IDLE,
    STATE_RUNNING,
    STATE_PAUSED,
    STATE_STOPPED
} State;

const char *describe(State s) {
    switch (s) {
        case STATE_IDLE:    return "wartet auf Arbeit";
        case STATE_RUNNING: return "arbeitet";
        case STATE_PAUSED:  return "vom Benutzer pausiert";
        case STATE_STOPPED: return "fertig";
    }
    return "unbekannt";
}

int main(void) {
    for (State s = STATE_IDLE; s <= STATE_STOPPED; s++) {
        printf("%d: %s\n", s, describe(s));
    }
    return 0;
}

Füge dem Enum ein STATE_FAILED hinzu, und GCC warnt: enumeration value 'STATE_FAILED' not handled in switch. Diese Warnung ist das, was C einer Vollständigkeitsprüfung am nächsten kommt, und sie ist ein starkes Argument, solche switches ohne einen default:-Fall zu schreiben - ein default bringt die Warnung zum Schweigen und lässt neue Zustände unbehandelt durchrutschen. Setze den Rückfall stattdessen hinter das switch, wie describe es tut.

Ein Enum in eine Zeichenkette umwandeln

C behält zur Laufzeit keine Namen; printf("%s", GREEN) kann nicht funktionieren, weil GREEN schlicht 1 ist. Zwei Muster lösen das.

Die switch-Variante, die der Compiler prüft:

#include <stdio.h>

typedef enum { RED, GREEN, BLUE, COLOR_COUNT } Color;

const char *color_name(Color c) {
    switch (c) {
        case RED:   return "RED";
        case GREEN: return "GREEN";
        case BLUE:  return "BLUE";
        case COLOR_COUNT: break;
    }
    return "UNKNOWN";
}

int main(void) {
    for (Color c = RED; c < COLOR_COUNT; c++) {
        printf("%d = %s\n", c, color_name(c));
    }
    return 0;
}

Und die Nachschlagetabellen-Variante, kürzer, aber ungeprüft - wenn Array und Enum auseinanderdriften, warnt nichts:

#include <stdio.h>

typedef enum { RED, GREEN, BLUE, COLOR_COUNT } Color;

static const char *COLOR_NAMES[COLOR_COUNT] = {
    [RED]   = "RED",
    [GREEN] = "GREEN",
    [BLUE]  = "BLUE",
};

const char *color_name(Color c) {
    if (c < 0 || c >= COLOR_COUNT) {
        return "UNKNOWN";
    }
    return COLOR_NAMES[c];
}

int main(void) {
    printf("%s %s %s\n", color_name(RED), color_name(GREEN), color_name(BLUE));
    printf("%s\n", color_name((Color)99));
    return 0;
}

Die benannten Array-Indizes ([RED] = "RED") halten die Namen immerhin an ihre Plätze gebunden, sodass ein Umsortieren des Enums die Zeichenketten nicht still durcheinanderbringen kann. Die Bereichsprüfung zählt, weil nichts einen Aufrufer daran hindert, einen Wert außerhalb des Enums zu übergeben - siehe den nächsten Abschnitt.

Enums sind nicht wasserdicht

Eine Enum-Variable ist darunter eine Ganzzahl, und C überwacht den Bereich nicht:

#include <stdio.h>

typedef enum { RED, GREEN, BLUE } Color;

int main(void) {
    Color c = (Color)42;      /* erlaubt; ueberhaupt keine Pruefung */
    int n = BLUE;             /* enum nach int: implizit und in Ordnung */

    printf("c = %d, n = %d\n", c, n);
    printf("RED + GREEN = %d\n", RED + GREEN);
    return 0;
}

Arithmetik mit Aufzählungswerten funktioniert, Vergleiche mit schlichten ints funktionieren, und ein Cast außerhalb des Bereichs wird akzeptiert. Behandle ein Enum also als ausgezeichnete Dokumentation und einen guten Hinweis für den Compiler, nicht als Garantie. Prüfe jeden Wert, der von außerhalb deines Programms kommt - eine Datei, ein Argument, eine Netznachricht -, bevor du darauf umschaltest.

Größe und Speicherung

In C17 muss jeder Aufzählungswert in ein int passen - enum Huge { BIG = 3000000000 }; ist eine Bedingungsverletzung, die ein strenger Compiler (-pedantic-errors) zurückweist, auch wenn gcc und clang sie in ihrem Standardmodus als Erweiterung akzeptieren. Die Aufzählungswerte selbst haben den Typ int, während die Größe des Enum-Typs implementierungsabhängig ist (in der Praxis int):

#include <stdio.h>

enum Small { A, B, C };
enum Flags { READ = 1, WRITE = 2, EXEC = 4 };

int main(void) {
    printf("sizeof(enum Small) = %zu\n", sizeof(enum Small));
    printf("sizeof(enum Flags) = %zu\n", sizeof(enum Flags));
    printf("sizeof(int)        = %zu\n", sizeof(int));
    return 0;
}

(C23 hebt die Einschränkung auf: ein Aufzählungswert darf den int-Bereich überschreiten, und du kannst mit enum E : unsigned long { ... } sogar den zugrunde liegenden Typ wählen. Solange deine Toolchain nicht C23 anvisiert, halte die Aufzählungswerte innerhalb von int.)

Weil die genaue Wahl implementierungsabhängig ist, schreibe ein Enum nie direkt in eine Binärdatei oder ein Netzpaket und erwarte, dass eine andere Maschine es zurücklesen kann. Wandle an der Grenze in einen Typ fester Breite wie uint8_t oder uint32_t aus <stdint.h> um.

Enum gegen #define

Beide geben einer Zahl einen Namen. Das Enum ist im Allgemeinen besser:

	`enum`	`#define`
Behandelt von	dem Compiler	dem Präprozessor
Gruppierung	zusammengehörige Werte teilen einen Typ	jede Konstante steht für sich
Automatische Nummerierung	ja	nein, du nummerierst von Hand
Im Debugger sichtbar	oft, mit Namen	nein, nur die Zahl
`switch`-Vollständigkeitswarnung	ja	nein
Gültigkeitsbereich	respektiert Blockgültigkeit	textuell, bis `#undef`

Greife zu #define, wenn die Konstante keine Ganzzahl ist (eine Zeichenkette, ein Gleitkommawert) oder wenn sie für den Präprozessor selbst nutzbar sein muss, wie bei der bedingten Übersetzung. Für einen Satz zusammengehöriger ganzzahliger Zustände, Flags oder Arten nimm ein Enum.

Namenskonventionen

Enums kollidieren leicht, weil ihre Namen im gewöhnlichen Gültigkeitsbereich sitzen. Die Konventionen, die große C-Codebasen bei Verstand halten:

Stelle jedem Aufzählungswert den Typ voran: COLOR_RED, STATE_IDLE, HTTP_OK. Ein unpräfigiertes RED in einem Grafikprogramm trifft irgendwann jemand anderes RED.
Schreibe die Aufzählungswerte in GROSSBUCHSTABEN, passend dazu, wie andere Konstanten aussehen.
Benenne den Typ im Singular in PascalCase oder als snake_case_t: Color, State oder color_t, projektweit einheitlich.
Füge zuletzt einen _COUNT-Wächter hinzu, wenn du mit dem Enum iterieren oder indizieren wirst.

Häufig gestellte Fragen

Wie definiert man ein enum in C?

enum Color { RED, GREEN, BLUE }; definiert einen Typ, dessen Werte die drei benannten Konstanten sind. Standardmäßig werden sie ab 0 nummeriert, RED ist also 0, GREEN ist 1 und BLUE ist 2. Deklariere eine Variable mit enum Color c = GREEN; oder füge ein typedef hinzu, damit du nur Color c schreiben kannst.

Kann man einem enum in C bestimmte Werte zuweisen?

Ja: enum Status { OK = 200, NOT_FOUND = 404, ERROR = 500 };. Du kannst einige setzen und die anderen folgen lassen - jeder Name ohne expliziten Wert zählt vom vorherigen weiter, enum { A = 10, B, C }; ergibt also B = 11 und C = 12.

Wie wandelt man ein enum in C in eine Zeichenkette um?

C hat dafür keinen eingebauten Weg; die Namen der Aufzählungswerte existieren zur Laufzeit nicht. Üblich ist eine kleine Funktion mit einem switch, die pro Wert ein Zeichenkettenliteral liefert, oder ein Array von Zeichenketten, das mit dem Enum indiziert wird. Die switch-Variante ist sicherer, weil -Wall warnt, wenn ein neuer Aufzählungswert keinen Fall hat.

Wie groß ist ein enum in C?

Implementierungsabhängig, in der Praxis aber sizeof(int) - 4 Bytes auf den meisten Systemen. Der Compiler wählt einen Ganzzahltyp, der jeden Aufzählungswert fassen kann. Nimm keine bestimmte Größe an, wenn du eine Binärdatei oder ein Netzpaket aufbaust; benutze dort einen Typ fester Breite aus <stdint.h>.

Verwandte Konzepte