Guida C interattiva: enum

Q: Come si definisce un enum in C?

enum Color { RED, GREEN, BLUE }; definisce un tipo i cui valori sono le tre costanti con nome. Di default sono numerate a partire da 0, quindi RED vale 0, GREEN vale 1 e BLUE vale 2. Dichiara una variabile con enum Color c = GREEN;, oppure aggiungi un typedef per poter scrivere solo Color c.

Q: Si possono assegnare valori specifici a un enum in C?

Sì: enum Status { OK = 200, NOT_FOUND = 404, ERROR = 500 };. Puoi impostarne alcuni e lasciare che gli altri seguano: ogni nome senza un valore esplicito continua da quello precedente, quindi enum { A = 10, B, C }; dà B = 11 e C = 12.

Q: Qual è la dimensione di un enum in C?

È definita dall'implementazione, ma in pratica è sizeof(int): 4 byte sulla maggior parte dei sistemi. Il compilatore sceglie un tipo intero in grado di contenere ogni enumeratore. Non dare per scontata una dimensione specifica quando definisci il layout di un file binario o di un pacchetto di rete; lì usa un tipo a larghezza fissa di .

Il codice pieno di numeri nudi è codice che nessuno riesce a leggere. if (state == 2) non ti dice nulla; if (state == STATE_RUNNING) ti dice tutto. Un enum è il modo del C per dare nomi veri a un piccolo insieme fisso di interi, e a differenza di una pila di #define, arrivano raggruppati in un unico tipo che il compilatore conosce.

Definire un enum

La dichiarazione dà un nome a un tag ed elenca gli enumeratori tra parentesi graffe:

#include <stdio.h>

enum Color {
    RED,
    GREEN,
    BLUE
};

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

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

Due cose da notare subito. Primo, la numerazione parte da 0 e aumenta di uno, quindi RED vale 0, GREEN vale 1, BLUE vale 2. Secondo, i nomi degli enumeratori sono visibili ovunque nello scope che li contiene: scrivi GREEN, non Color.GREEN. Vivono nello stesso spazio dei nomi delle tue variabili, ed è per questo che il codice C per convenzione li scrive in MAIUSCOLO o li prefissa con il tipo (COLOR_RED) per evitare collisioni.

Per stampare un enum si usa %d, perché un valore di un'enumerazione è un valore intero.

Valori espliciti

Assegna a un enumeratore qualsiasi una costante esplicita, e quelli successivi continuano da lì:

#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;
}

I valori non devono essere unici né ordinati: due enumeratori possono condividere un numero, cosa ogni tanto utile per gli alias (COLOR_DEFAULT = COLOR_BLACK). Devono essere costanti intere di compilazione, quindi non puoi calcolarne uno da una variabile.

Un idioma comune sfrutta questo per registrare il conteggio:

enum Suit {
    CLUBS, DIAMONDS, HEARTS, SPADES,
    SUIT_COUNT           /* vale automaticamente 4 e resta corretto se aggiungi un seme */
};

SUIT_COUNT non è un vero seme; è il loro numero, mantenuto gratis dalla numerazione automatica. Cicli e dimensioni di array possono usarlo senza mai diventare obsoleti.

typedef enum

Come per le struct, il nome completo del tipo in C è enum Color, e un typedef elimina la parola chiave:

#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("arrivato a (%d, %d)\n", x, y);
    return 0;
}

Poiché gli enumeratori sono normali interi che partono da 0, fanno anche da indici di array: dx[DIR_EAST] funziona senza alcuna conversione. È la proprietà più utile in assoluto di un enum che parte da zero.

Enum in uno switch

Abbinare un enum a uno switch è il punto in cui il tipo inizia a ripagarsi. Compila con -Wall e il compilatore ti dirà quando dimentichi un case.

#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 "in attesa di lavoro";
        case STATE_RUNNING: return "al lavoro";
        case STATE_PAUSED:  return "messo in pausa dall'utente";
        case STATE_STOPPED: return "terminato";
    }
    return "sconosciuto";
}

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

Aggiungi uno STATE_FAILED all'enum e GCC avvisa: enumeration value 'STATE_FAILED' not handled in switch. Quell'avviso è la cosa più vicina a un controllo di esaustività che il C abbia, ed è un forte motivo per scrivere questi switch senza un case default:: un default zittisce l'avviso e lascia passare senza gestione i nuovi stati. Metti invece il caso di ripiego dopo lo switch, come fa describe.

Convertire un enum in stringa

Il C non conserva nomi a runtime; printf("%s", GREEN) non può funzionare perché GREEN è semplicemente 1. Due schemi risolvono il problema.

La versione con lo switch, che il compilatore controlla:

#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;
}

E la versione con tabella di lookup, più breve ma non controllata: se l'array e l'enum si disallineano, nessuno avvisa:

#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;
}

Gli indici designati dell'array ([RED] = "RED") almeno tengono i nomi legati alle loro posizioni, quindi riordinare l'enum non può mescolare le stringhe in silenzio. Il controllo dei limiti conta perché niente impedisce a chi chiama di passare un valore fuori dall'enum: vedi la prossima sezione.

Gli enum non sono a tenuta stagna

Una variabile enum sotto sotto è un intero, e il C non sorveglia l'intervallo:

#include <stdio.h>

typedef enum { RED, GREEN, BLUE } Color;

int main(void) {
    Color c = (Color)42;      /* lecito; nessun controllo */
    int n = BLUE;             /* da enum a int: implicito e senza problemi */

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

L'aritmetica sugli enumeratori funziona, i confronti con semplici int funzionano e un cast fuori intervallo viene accettato. Quindi tratta un enum come un'ottima documentazione e un buon suggerimento per il compilatore, non come una garanzia. Valida qualsiasi valore che arriva dall'esterno del programma, un file, un argomento, un messaggio di rete, prima di usarlo in uno switch.

Dimensione e memorizzazione

In C17 ogni enumeratore deve stare in un int: enum Huge { BIG = 3000000000 }; è una violazione di vincolo che un compilatore rigoroso (-pedantic-errors) rifiuta, anche se gcc e clang lo accettano come estensione nella modalità predefinita. Gli enumeratori stessi hanno tipo int, mentre la dimensione del tipo enum è definita dall'implementazione (in pratica, 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 elimina la restrizione: un enumeratore può superare l'intervallo di int e puoi perfino scegliere il tipo sottostante con enum E : unsigned long { ... }. Finché la tua toolchain non punta a C23, tieni gli enumeratori dentro int.)

Poiché la scelta esatta è definita dall'implementazione, non scrivere mai un enum direttamente in un file binario o in un pacchetto di rete aspettandoti che un'altra macchina lo rilegga. Convertilo al confine in un tipo a larghezza fissa come uint8_t o uint32_t di <stdint.h>.

Enum contro #define

Entrambi danno un nome a un numero. In genere l'enum è migliore:

	`enum`	`#define`
Gestito da	il compilatore	il preprocessore
Raggruppamento	i valori collegati condividono un tipo	ogni costante è indipendente
Numerazione automatica	sì	no, numeri a mano
Visibile in un debugger	spesso, per nome	no, solo il numero
Avviso di esaustività nello `switch`	sì	no
Scope	rispetta lo scope di blocco	testuale, fino a `#undef`

Usa #define quando la costante non è un intero (una stringa, un float) o quando deve essere usabile dal preprocessore stesso, come nella compilazione condizionale. Per un insieme di stati, flag o tipi interi collegati, usa un enum.

Convenzioni per i nomi

Gli enum collidono facilmente perché i loro nomi stanno nello scope ordinario. Le convenzioni che mantengono sane le grandi codebase C:

Prefissa ogni enumeratore con il tipo: COLOR_RED, STATE_IDLE, HTTP_OK. Un RED senza prefisso in un programma grafico prima o poi incontrerà il RED di qualcun altro.
Scrivi gli enumeratori in SHOUT_CASE, come le altre costanti.
Dai al tipo un nome singolare in PascalCase o snake_case_t: Color, State o color_t, in modo coerente in tutto il progetto.
Aggiungi una sentinella _COUNT in fondo quando userai l'enum per cicli o indici.

Domande frequenti

Come si definisce un enum in C?

enum Color { RED, GREEN, BLUE }; definisce un tipo i cui valori sono le tre costanti con nome. Di default sono numerate a partire da 0, quindi RED vale 0, GREEN vale 1 e BLUE vale 2. Dichiara una variabile con enum Color c = GREEN;, oppure aggiungi un typedef per poter scrivere solo Color c.

Si possono assegnare valori specifici a un enum in C?

Sì: enum Status { OK = 200, NOT_FOUND = 404, ERROR = 500 };. Puoi impostarne alcuni e lasciare che gli altri seguano: ogni nome senza un valore esplicito continua da quello precedente, quindi enum { A = 10, B, C }; dà B = 11 e C = 12.

Come si converte un enum in stringa in C?

Il C non ha un modo predefinito; i nomi degli enumeratori non esistono a runtime. L'approccio abituale è una piccola funzione con uno switch che restituisce una stringa letterale per ogni valore, oppure un array di stringhe indicizzato dall'enum. La versione con lo switch è più sicura, perché -Wall avvisa quando un nuovo enumeratore non ha un case.

Qual è la dimensione di un enum in C?

È definita dall'implementazione, ma in pratica è sizeof(int): 4 byte sulla maggior parte dei sistemi. Il compilatore sceglie un tipo intero in grado di contenere ogni enumeratore. Non dare per scontata una dimensione specifica quando definisci il layout di un file binario o di un pacchetto di rete; lì usa un tipo a larghezza fissa di <stdint.h>.

Concetti correlati