Union trong C: bộ nhớ dùng chung, union và struct, tagged union

Struct nói "tất cả những thứ này, cùng lúc". union nói "đúng một trong số này, tại mỗi thời điểm". Các thành viên nằm chồng lên nhau tại cùng một địa chỉ, nên union chỉ lớn bằng thành viên lớn nhất, và ghi vào một thành viên sẽ phá hủy các thành viên còn lại.

Nghe thì giống một cái bẫy, và nếu không kiểm soát thì đúng là bẫy thật. Nhưng đây cũng là cách C biểu diễn một giá trị có thể thuộc một trong nhiều loại, chẳng hạn một token là số hoặc chuỗi, một thông điệp là cú nhấp chuột hoặc phím bấm, mà không phải trả chi phí bộ nhớ cho tất cả cùng lúc.

Khai báo và dùng union

Cú pháp giống hệt struct, chỉ khác từ khóa (keyword).

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

Các thành viên được truy cập bằng . (hoặc -> qua con trỏ), y như với struct. Điểm khác là chỉ thành viên được ghi gần nhất mới chứa giá trị có nghĩa. Sau v.f = 3.5f, đọc v.i không cho bạn 3, mà cho ra số nguyên nào đó tình cờ được tạo thành từ mẫu bit của 3.5f.

Kích thước: thành viên lớn nhất quyết định

So sánh cách bố trí bộ nhớ của một struct và một union có cùng các thành viên:

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

Trên một máy thông thường, struct chiếm 24 byte (4 cho int, 8 cho double, 1 cho char, cộng thêm phần đệm padding), còn union chỉ chiếm 8 byte, tức kích thước của double, làm tròn lên cho đúng căn chỉnh. Ba địa chỉ in ra giống hệt nhau, và đó là toàn bộ câu chuyện về union trong một dòng đầu ra.

Để ý phép ép kiểu sang void * khi dùng %p. printf yêu cầu đúng kiểu đó cho %p; truyền một kiểu con trỏ khác là undefined behavior, dù thường trông như vẫn chạy được. Xem thêm format specifier.

Khởi tạo union

Bộ khởi tạo dùng dấu ngoặc nhọn mà không có designator sẽ khởi tạo thành viên đầu tiên:

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

Bạn nên dùng dạng có designator. {42} ngầm phụ thuộc vào thứ tự thành viên, nên nếu sau này đổi thứ tự khai báo thì thành viên được khởi tạo cũng đổi theo. Đây là một bug thật sự khó chịu, vì nhìn vào code chẳng thấy gì khác.

Vấn đề thật sự: thành viên nào đang có hiệu lực?

Union không ghi lại bạn đã ghi vào thành viên nào gần nhất. Nó chỉ là các byte; thông tin đó nằm trong đầu bạn, và đó chính là nơi thông tin hay bị thất lạc.

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

Con số in ra rất lớn và kỳ lạ: đó là mẫu bit của 1.0f được đọc như một int. Không có gì bị crash, không có cảnh báo nào, và chương trình âm thầm sai. Union làm đúng những gì nó hứa; lỗi là của chúng ta khi quên thành viên nào đang có hiệu lực.

Cách khắc phục: tagged union

Giải pháp chuẩn là ghép union với một enum ghi lại thành viên đang có hiệu lực, rồi gói cả hai vào một struct. Sự kết hợp này gọi là tagged union (hay discriminated union), và gần như mọi union trong code ứng dụng đều nên được viết theo cách này.

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

Giờ mọi lần đọc đều đi qua switch trên kind, nên không thể đọc một thành viên chưa từng được ghi, miễn là mỗi lần ghi đều cập nhật cả tag. Gói các lần ghi vào những hàm khởi tạo nhỏ (value_from_int, value_from_string) là cách thường dùng để không bao giờ quên bước đó.

Lượng bộ nhớ tiết kiệm được là có thật: mỗi Value ở đây tốn 24 byte payload cộng với tag, thay vì 4 + 4 + 24 cho một struct chứa cả ba. Với một trăm nghìn giá trị như vậy, chênh lệch là đáng kể.

Biên dịch với -Wall thêm một lớp bảo vệ thứ hai: nếu sau này bạn thêm VAL_BOOL vào enum mà quên viết case cho nó, GCC sẽ cảnh báo về giá trị enum chưa được xử lý.

Anonymous union

C11 cho phép đặt một thành viên union không có tên bên trong struct, khi đó các thành viên của nó được đưa lên không gian tên của struct bên ngoài:

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

Vì bản thân union không có tên, bạn viết s->circle.r thay vì s->as.circle.r. Code ngắn gọn hơn, đổi lại việc có một union ở đó bị che đi, và điều này không sao cả khi tag nằm ngay bên cạnh.

Khi nào union thật sự hữu ích

Bốn trường hợp dùng thường gặp:

• Giá trị nhiều dạng (variant). Trình thông dịch, bộ phân tích JSON và tệp cấu hình, hàng đợi thông điệp đều mang những giá trị mà kiểu chỉ được xác định khi chương trình chạy. Tagged union là cách biểu diễn kinh điển cho chúng.
• Bản ghi tiết kiệm bộ nhớ. Khi một struct có nhiều trường loại trừ lẫn nhau và bạn có hàng triệu bản ghi như vậy, đặt chồng các trường lên nhau giúp tiết kiệm bộ nhớ trực tiếp.
• Bố cục giao thức và phần cứng. Một gói tin có phần nội dung phụ thuộc vào một byte header rất hợp để ánh xạ sang tagged union, các thanh ghi thiết bị cũng vậy.
• Xem từng byte. Đặt chồng một giá trị với mảng unsigned char[] cho phép bạn xem từng byte của nó, chẳng hạn để xác định 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;
}

Đây là type punning: cố ý đọc lại các byte theo một kiểu khác. Đọc qua union như thế này được C cho phép một cách tường minh, với kết quả phụ thuộc vào cách cài đặt (implementation-defined), khác với ép kiểu con trỏ giữa các kiểu không liên quan, vốn vi phạm quy tắc aliasing. Còn xem các byte dưới dạng unsigned char thì luôn an toàn. Diễn giải lại một int thành float lại là chuyện khác: kết quả hoàn toàn phụ thuộc vào cách biểu diễn trên nền tảng của bạn, nên đừng đưa nó vào code cần chạy được trên nhiều nền tảng.

Lỗi thường gặp

• Đọc một thành viên bạn chưa ghi. Mối nguy hàng đầu. Hãy dùng tag.
• Nghĩ rằng union sẽ chuyển đổi giá trị. Không hề. u.i = 3; float f = u.f; diễn giải lại các bit; còn int i = 3; float f = i; mới là chuyển đổi. Xem ép kiểu.
• Đặt con trỏ vào union rồi mất dấu nó. Nếu một nhánh chứa char * mà bạn đã cấp phát, ghi đè union bằng một thành viên khác sẽ gây rò rỉ bộ nhớ, vì không còn gì trỏ tới vùng đệm đó nữa. Giải phóng trước khi chuyển nhánh.
• Trông chờ trình biên dịch kiểm tra giúp. Nó sẽ không làm vậy. Union là một trong số ít tính năng của C mà ngôn ngữ không hỗ trợ gì ngoài kích thước và căn chỉnh; tag là hàng rào bảo vệ duy nhất của bạn.