Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / C

Unione con discriminante in C

Un’unione con discriminante abbina un campo `enum` a dati di tipo `union`. Il discriminante indica quale variante è stata memorizzata e quale membro leggere.

Versione: ISO C23; implementation support may vary

Sintassi

enum Kind { CPU_MS, REQUESTS };
struct Metric {
    enum Kind kind;
    union { int cpu_ms; unsigned requests; } value;
};

struct Metric m = { .kind = CPU_MS, .value = { .cpu_ms = 120 } };
/* Equivalent initialization with a chained designator: */
struct Metric same = { .kind = CPU_MS, .value.cpu_ms = 120 };

Un’unione con discriminante è uno schema, non un costrutto distinto del linguaggio C. Una struct contiene il discriminante kind di tipo enum e i dati value di tipo union. I membri dell’unione condividono la memoria: vi è memorizzato il valore di al più un membro alla volta. Il nome del tipo Metric in struct Metric non è il discriminante memorizzato nell’oggetto.

Il programma deve mantenere l’invariante: CPU_MS indica un valore memorizzato in cpu_ms, mentre REQUESTS ne indica uno memorizzato in requests. Quando cambi variante, scrivi sia i nuovi dati sia il discriminante corrispondente. Esamina kind con switch prima di leggere il membro corrispondente. default rifiuta un discriminante sconosciuto, ma non rileva un’incoerenza se il discriminante è riconosciuto. Leggere un altro membro può reinterpretare la rappresentazione dell’oggetto e non è un’alternativa portabile alla conversione di un valore.

In un inizializzatore designato, .membro = valore seleziona un membro per nome, anziché per posizione. In .value = { .cpu_ms = 120 }, le parentesi graffe interne si riferiscono all’unione value, quindi { .cpu_ms = 120 } seleziona cpu_ms. Il designatore concatenato .value.cpu_ms = 120 seleziona lo stesso membro annidato. Questa sintassi è standard da C99 e non richiede C23.

NULL, disponibile in <stddef.h>, è una macro che si espande in una costante di puntatore nullo, non un numero di elementi. print_metrics(NULL, 0) gestisce esplicitamente il caso vuoto senza accedere ad alcun elemento; print_metrics(NULL, 1) rifiuta argomenti incoerenti. Se il puntatore non è nullo, il chiamante deve garantire che n elementi inizializzati siano ancora in vita e accessibili.

Esempi

#include <stddef.h>
#include <stdio.h>

enum Kind { CPU_MS, REQUESTS };

struct Metric {
    enum Kind kind;
    union {
        int cpu_ms;
        unsigned requests;
    } value;
};

static void print_metrics(const struct Metric *metrics, size_t n)
{
    if (metrics == NULL) {
        puts(n == 0 ? "empty" : "invalid input");
        return;
    }

    for (size_t i = 0; i < n; ++i) {
        switch (metrics[i].kind) {
        case CPU_MS:
            printf("cpu_ms=%d\n", metrics[i].value.cpu_ms);
            break;
        case REQUESTS:
            printf("requests=%u\n", metrics[i].value.requests);
            break;
        default:
            puts("invalid tag");
            return;
        }
    }
}

int main(void)
{
    const struct Metric metrics[] = {
        { .kind = CPU_MS, .value = { .cpu_ms = 120 } },
        { .kind = REQUESTS, .value.requests = 7u }
    };

    print_metrics(metrics, sizeof metrics / sizeof metrics[0]);
    print_metrics(NULL, 0);
    print_metrics(NULL, 1);
    return 0;
}

Risultato

cpu_ms=120
requests=7
empty
invalid input

Il programma stampa due valori di varianti diverse, poi mostra come vengono gestiti un conteggio pari a zero e uno positivo con `NULL`.

Lezioni correlate

  • C · Lezione 78 · Avanzato · Versione: 3

Fonti