Union di C: Memori Bersama, Union vs Struct, dan Tagged Union

Struct berkata "semua ini, bersama-sama". union berkata "tepat satu dari ini, pada satu waktu". Anggota-anggotanya ditumpuk di alamat yang sama, jadi union hanya sebesar anggota terbesarnya, dan menulis satu anggota akan menghancurkan anggota lainnya.

Kedengarannya seperti jebakan, dan tanpa pengecekan memang begitu. Tetapi itu juga cara C menyatakan sebuah nilai yang bisa berupa salah satu dari beberapa jenis, seperti token yang berupa angka atau string, atau pesan yang berupa klik atau tekanan tombol, tanpa harus membayar untuk semuanya sekaligus.

Mendeklarasikan dan Memakai Union

Sintaksnya persis meniru struct; hanya kata kuncinya yang berubah.

#include <stdio.h>

union Value {
    int i;
    float f;
    char c;
};

int main(void) {
    union Value v;

    v.i = 42;
    printf("as int:   %d\n", v.i);

    v.f = 3.5f;                 /* overwrites the same bytes */
    printf("as float: %.1f\n", v.f);

    v.c = 'A';
    printf("as char:  %c\n", v.c);
    return 0;
}

Anggota diakses dengan . (atau -> lewat pointer), persis seperti struct. Bedanya, hanya anggota yang paling akhir ditulis yang berisi nilai bermakna. Setelah v.f = 3.5f, membaca v.i tidak memberimu 3, melainkan integer apa pun yang kebetulan terbentuk dari pola bit 3.5f.

Ukuran: Anggota Terbesar yang Menang

Bandingkan tata letak memori struct dan union dengan anggota yang sama:

#include <stdio.h>

struct S {
    int    i;
    double d;
    char   c;
};

union U {
    int    i;
    double d;
    char   c;
};

int main(void) {
    printf("sizeof(struct S) = %zu\n", sizeof(struct S));
    printf("sizeof(union  U) = %zu\n", sizeof(union U));

    union U u;
    printf("&u.i = %p\n", (void *)&u.i);
    printf("&u.d = %p\n", (void *)&u.d);
    printf("&u.c = %p\n", (void *)&u.c);
    return 0;
}

Di mesin pada umumnya, struct-nya berukuran 24 byte (4 untuk int, 8 untuk double, 1 untuk char, ditambah padding), sedangkan union-nya 8 byte, yaitu ukuran double-nya, dibulatkan ke atas demi alignment. Ketiga alamat yang dicetak identik, dan itulah seluruh cerita tentang union dalam satu baris output.

Perhatikan cast %p ke void *. printf mengharapkan persis itu untuk %p; mengirim tipe pointer lain adalah undefined behavior walaupun biasanya tampak berjalan. Lihat format specifier.

Menginisialisasi Union

Inisialisasi dengan kurung kurawal tanpa designator akan menginisialisasi anggota pertama:

#include <stdio.h>

union Value {
    int i;
    float f;
};

int main(void) {
    union Value a = {42};              /* initializes .i, the first member */
    union Value b = {.f = 3.5f};       /* designated: initializes .f       */

    printf("a.i = %d\n", a.i);
    printf("b.f = %.1f\n", b.f);
    return 0;
}

Bentuk designated adalah yang sebaiknya dipakai. {42} diam-diam bergantung pada urutan anggota, jadi mengubah urutan deklarasi nanti akan mengubah anggota mana yang diinisialisasi. Ini bug yang sungguh menjengkelkan, karena tidak ada yang tampak berbeda pada kodenya.

Masalah Sebenarnya: Anggota Mana yang Aktif?

Union tidak mencatat anggota mana yang terakhir kamu tulis. Isinya hanya byte; pengetahuan itu ada di kepalamu, dan justru di situlah pengetahuan sering hilang.

#include <stdio.h>

union Value {
    int i;
    float f;
};

int main(void) {
    union Value v;
    v.f = 1.0f;

    /* Reading .i now reinterprets the float's bits as an integer. */
    printf("wrote 1.0f, read back as int: %d\n", v.i);
    return 0;
}

Angka yang tercetak besar dan aneh: pola bit 1.0f yang dibaca sebagai int. Tidak ada yang crash, tidak ada peringatan, dan programnya diam-diam salah. Union melakukan persis apa yang dijanjikannya; kesalahannya ada pada kita yang lupa anggota mana yang sedang aktif.

Solusinya: Tagged Union

Solusi standarnya adalah memasangkan union dengan enum yang mencatat anggota yang aktif, lalu membungkus keduanya dalam sebuah struct. Kombinasi itu disebut tagged union (atau discriminated union), dan begitulah seharusnya kamu menulis hampir setiap union di kode aplikasi.

#include <stdio.h>
#include <string.h>

typedef enum {
    VAL_INT,
    VAL_FLOAT,
    VAL_STRING
} ValueKind;

typedef struct {
    ValueKind kind;           /* the tag: which member is live */
    union {
        int   i;
        float f;
        char  s[24];
    } as;                     /* the payload */
} Value;

void print_value(const Value *v) {
    switch (v->kind) {
        case VAL_INT:    printf("int    %d\n", v->as.i);    break;
        case VAL_FLOAT:  printf("float  %.2f\n", v->as.f);  break;
        case VAL_STRING: printf("string \"%s\"\n", v->as.s); break;
    }
}

int main(void) {
    Value values[3];

    values[0].kind = VAL_INT;
    values[0].as.i = 42;

    values[1].kind = VAL_FLOAT;
    values[1].as.f = 3.14f;

    values[2].kind = VAL_STRING;
    snprintf(values[2].as.s, sizeof values[2].as.s, "hello");

    for (int i = 0; i < 3; i++) {
        print_value(&values[i]);
    }
    return 0;
}

Setiap pembacaan kini melewati switch pada kind, jadi mustahil membaca anggota yang tidak pernah ditulis, selama setiap penulisan juga mengisi tag-nya. Membungkus penulisan dalam fungsi konstruktor kecil (value_from_int, value_from_string) adalah cara yang umum agar hal itu tidak mungkin terlupa.

Penghematan memorinya nyata: setiap Value di sini memakan 24 byte payload ditambah tag, bukan 4 + 4 + 24 untuk struct yang menampung ketiganya. Dengan seratus ribu nilai seperti itu, selisihnya terasa.

Compile dengan -Wall menambahkan jaring pengaman kedua: jika nanti kamu menambahkan VAL_BOOL ke enum dan lupa membuat case untuknya, GCC akan memberi peringatan soal nilai enum yang tidak ditangani.

Anonymous Union

C11 mengizinkan anggota union tanpa nama di dalam struct, sehingga anggota-anggotanya naik ke namespace struct luarnya:

#include <stdio.h>

typedef enum { SHAPE_CIRCLE, SHAPE_RECT } ShapeKind;

typedef struct {
    ShapeKind kind;
    union {                       /* no member name */
        struct { double r; } circle;
        struct { double w, h; } rect;
    };
} Shape;

double area(const Shape *s) {
    switch (s->kind) {
        case SHAPE_CIRCLE: return 3.14159265 * s->circle.r * s->circle.r;
        case SHAPE_RECT:   return s->rect.w * s->rect.h;
    }
    return 0.0;
}

int main(void) {
    Shape a = {.kind = SHAPE_CIRCLE, .circle = {.r = 2.0}};
    Shape b = {.kind = SHAPE_RECT,   .rect = {.w = 3.0, .h = 4.0}};

    printf("circle: %.4f\n", area(&a));
    printf("rect:   %.4f\n", area(&b));
    return 0;
}

Karena union-nya sendiri tidak bernama, kamu menulis s->circle.r, bukan s->as.circle.r. Lebih pendek untuk dibaca, dengan konsekuensi menyembunyikan fakta bahwa ada union di sana, dan itu tidak masalah selama tag-nya ada tepat di sampingnya.

Kapan Union Benar-benar Berguna

Empat pemakaian yang sering muncul:

• Nilai varian. Interpreter, parser JSON dan konfigurasi, serta antrean pesan semuanya membawa nilai yang tipenya baru ditentukan saat program berjalan. Tagged union adalah representasi kanoniknya.
• Record yang hemat memori. Jika sebuah struct punya beberapa field yang saling eksklusif dan jumlahnya jutaan, menumpuknya langsung menghemat memori.
• Tata letak protokol dan hardware. Paket yang isinya bergantung pada sebuah byte header cocok dipetakan ke tagged union, begitu juga register perangkat.
• Memeriksa byte. Menumpuk sebuah nilai dengan array unsigned char[] memungkinkanmu melihat byte-byte individunya, misalnya untuk menentukan endianness:

#include <stdio.h>

int main(void) {
    union {
        unsigned int  value;
        unsigned char bytes[sizeof(unsigned int)];
    } probe;

    probe.value = 0x01020304u;

    for (size_t i = 0; i < sizeof probe.bytes; i++) {
        printf("%02X ", probe.bytes[i]);
    }
    printf("\n");
    printf("%s-endian\n", probe.bytes[0] == 0x04 ? "little" : "big");
    return 0;
}

Ini disebut type punning: sengaja membaca kembali byte sebagai tipe lain. Membaca lewat union seperti ini secara eksplisit diizinkan di C dengan hasil yang implementation-defined (berbeda dengan cast pointer antartipe yang tidak berhubungan, yang melanggar aturan aliasing), dan memeriksa byte sebagai unsigned char selalu aman. Menafsirkan ulang int sebagai float adalah perkara lain: hasilnya sepenuhnya bergantung pada representasi di platform-mu, jadi jauhkan dari kode yang harus portabel.

Kesalahan Umum

• Membaca anggota yang tidak kamu tulis. Bahaya utamanya. Pakai tag.
• Menganggap union melakukan konversi. Tidak. u.i = 3; float f = u.f; menafsirkan ulang bit; int i = 3; float f = i; melakukan konversi. Lihat type casting.
• Menaruh pointer di dalam union lalu kehilangan jejaknya. Jika satu cabang berisi char * yang kamu alokasikan, menimpa union dengan anggota lain akan membocorkannya, karena tidak ada lagi yang menunjuk ke buffer itu. Bebaskan dulu sebelum berganti cabang.
• Berharap compiler akan mengecek. Tidak akan. Union adalah salah satu dari sedikit fitur C di mana bahasanya sama sekali tidak memberi bantuan selain soal ukuran dan alignment; tag-nya adalah satu-satunya pagar pengamanmu.