Base de conhecimentoCentro de Exames
PT · PTPortuguês (Portugal)
Escolher idioma13

CKTIS / C

União etiquetada em C

Uma união etiquetada combina um campo `enum` com dados do tipo `union`. A etiqueta indica que variante foi guardada e que membro deve ser lido.

Versão: ISO C23; implementation support may vary

Sintaxe

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

Uma união etiquetada é um padrão, não uma construção própria da linguagem C. Uma struct contém a etiqueta kind do tipo enum e os dados value do tipo union. Os membros da união partilham a memória: só pode estar guardado o valor de, no máximo, um membro de cada vez. O nome de tipo Metric em struct Metric não é a etiqueta guardada no objeto.

O programa tem de manter o invariante: CPU_MS indica um valor guardado em cpu_ms, e REQUESTS, um valor guardado em requests. Ao mudar de variante, escreve tanto os novos dados como a etiqueta correspondente. Verifica kind com switch antes de ler o membro correspondente. default rejeita uma etiqueta desconhecida, mas não deteta uma inconsistência se a etiqueta for reconhecida. Ler outro membro pode reinterpretar a representação do objeto e não é uma alternativa portável à conversão de um valor.

Num inicializador designado, .membro = valor seleciona um membro pelo nome, e não pela posição. Em .value = { .cpu_ms = 120 }, as chavetas interiores referem-se à união value, pelo que { .cpu_ms = 120 } seleciona cpu_ms. O designador encadeado .value.cpu_ms = 120 seleciona o mesmo membro aninhado. Esta sintaxe faz parte da norma desde C99 e não exige C23.

NULL, disponível em <stddef.h>, é uma macro que se expande para uma constante de ponteiro nulo, não um número de elementos. print_metrics(NULL, 0) trata explicitamente o caso vazio sem aceder a qualquer elemento; print_metrics(NULL, 1) rejeita argumentos incoerentes. Se o ponteiro não for nulo, quem chama a função tem de garantir que n elementos inicializados continuam vivos e acessíveis.

Exemplos

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

Resultado

cpu_ms=120
requests=7
empty
invalid input

O programa imprime dois valores de variantes diferentes e mostra depois como são tratadas uma contagem nula e uma contagem positiva com `NULL`.

Lições relacionadas

  • C · Lição 78 · Avançado · Versão: 3

Fontes