Union ב-C: זיכרון משותף, union מול struct ו-tagged union

struct אומר "את כל אלה, ביחד". union אומר "בדיוק אחד מאלה, בכל רגע". האיברים מונחים זה על גבי זה באותה כתובת, ולכן ה-union גדול רק כמו האיבר הגדול ביותר שלו, וכתיבה לאיבר אחד הורסת את האחרים.

זה נשמע כמו מלכודת, ובלי שליטה זה באמת מלכודת. אבל זו גם הדרך של C לבטא ערך שיכול להיות אחד מכמה סוגים, כמו token שהוא מספר או מחרוזת, או הודעה שהיא לחיצת עכבר או הקשה על מקש, בלי לשלם על כולם בבת אחת.

הצהרה ושימוש ב-union

התחביר זהה לחלוטין לזה של struct; רק מילת המפתח משתנה.

#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;                 /* דורס את אותם בתים */
    printf("as float: %.1f\n", v.f);

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

ניגשים לאיברים עם . (או עם -> דרך מצביע), בדיוק כמו ב-struct. ההבדל הוא שרק האיבר שנכתב אחרון מחזיק ערך בעל משמעות. אחרי v.f = 3.5f, קריאה של v.i לא נותנת 3: היא נותנת את המספר השלם שתבנית הביטים של 3.5f יוצרת במקרה.

גודל: האיבר הגדול ביותר מנצח

השוו את פריסת הזיכרון של struct ושל union עם אותם איברים:

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

במכונה טיפוסית ה-struct תופס 24 בתים (4 ל-int, 8 ל-double, 1 ל-char, ועוד ריפוד) בעוד שה-union תופס 8: הגודל של ה-double שלו, מעוגל לצורך יישור. שלוש הכתובות שמודפסות זהות, וזה כל הסיפור של union בשורת פלט אחת.

שימו לב להמרות ל-void * עבור %p. printf מצפה בדיוק לזה עבור %p; העברה של טיפוס מצביע אחר היא התנהגות לא מוגדרת, גם אם בדרך כלל זה נראה עובד. ראו format specifiers.

אתחול של union

אתחול בסוגריים מסולסלים בלי designator מאתחל את האיבר הראשון:

#include <stdio.h>

union Value {
    int i;
    float f;
};

int main(void) {
    union Value a = {42};              /* מאתחל את .i, האיבר הראשון */
    union Value b = {.f = 3.5f};       /* designated: מאתחל את .f   */

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

הצורה עם ה-designator היא זו שכדאי להשתמש בה. {42} תלוי בשקט בסדר האיברים, כך ששינוי הסדר בהצהרה בהמשך משנה איזה איבר מאותחל: באג מגעיל באמת, כי שום דבר בקוד לא נראה אחרת.

הבעיה האמיתית: איזה איבר חי?

union לא זוכר איזה איבר כתבתם אחרון. הוא רק בתים; הידע נמצא אצלכם בראש, ובדיוק שם ידע הולך לאיבוד.

#include <stdio.h>

union Value {
    int i;
    float f;
};

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

    /* קריאה של .i עכשיו מפרשת את הביטים של ה-float כמספר שלם. */
    printf("wrote 1.0f, read back as int: %d\n", v.i);
    return 0;
}

המספר שמודפס גדול ומוזר: תבנית הביטים של 1.0f כשקוראים אותה כ-int. שום דבר לא קרס, שום דבר לא הזהיר, והתוכנית שגויה בשקט. ה-union עשה בדיוק את מה שהבטיח; הטעות הייתה שלנו, ששכחנו איזה איבר חי.

הפתרון: tagged union

הפתרון הסטנדרטי הוא לצרף ל-union enum שמתעד את האיבר החי, ולעטוף את שניהם ב-struct. השילוב הזה נקרא tagged union (או discriminated union), וכך כדאי לכתוב בעצם כל union בקוד של אפליקציה.

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

typedef enum {
    VAL_INT,
    VAL_FLOAT,
    VAL_STRING
} ValueKind;

typedef struct {
    ValueKind kind;           /* התגית: איזה איבר חי */
    union {
        int   i;
        float f;
        char  s[24];
    } as;                     /* המטען */
} 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;
}

כל קריאה עוברת עכשיו דרך ה-switch על kind, כך שאי אפשר לקרוא איבר שאף פעם לא נכתב, כל עוד כל כתיבה מעדכנת גם את התגית. עטיפת הכתיבות בפונקציות בנייה קטנות (value_from_int, value_from_string) היא הדרך המקובלת להפוך את זה לבלתי אפשרי לשכוח.

החיסכון בזיכרון אמיתי: כל Value כאן עולה 24 בתים של מטען ועוד התגית, במקום 4 + 4 + 24 של struct שמחזיק את שלושתם. כשיש מאה אלף כאלה, זה משנה.

קימפול עם -Wall מוסיף רשת ביטחון שנייה: אם בהמשך תוסיפו VAL_BOOL ל-enum ותשכחו case בשבילו, GCC יזהיר על ערך enum שלא טופל.

Unions אנונימיים

C11 מתיר איבר union בלי שם בתוך struct, ומעלה את האיברים שלו למרחב השמות של ה-struct החיצוני:

#include <stdio.h>

typedef enum { SHAPE_CIRCLE, SHAPE_RECT } ShapeKind;

typedef struct {
    ShapeKind kind;
    union {                       /* בלי שם איבר */
        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;
}

מכיוון שה-union עצמו בלי שם, כותבים s->circle.r במקום s->as.circle.r. קצר יותר לקריאה, במחיר הסתרת העובדה שיש כאן union בכלל, וזה בסדר כשהתגית נמצאת ממש לידו.

איפה unions באמת מצדיקים את עצמם

ארבעה שימושים חוזרים:

• ערכים משתנים (variants). מפרשים, parsers של JSON ושל קובצי הגדרות ותורי הודעות, כולם נושאים ערכים שהטיפוס שלהם נקבע בזמן ריצה. tagged union הוא הייצוג הקנוני.
• רשומות חסכוניות בזיכרון. כשב-struct יש כמה שדות שמוציאים זה את זה ויש לכם מיליונים כאלה, הנחתם זה על זה היא חיסכון ישיר.
• פריסות של פרוטוקולים וחומרה. חבילה שהמטען שלה תלוי בבית של כותרת ממופה באופן טבעי ל-tagged union, וכך גם אוגרים של התקנים.
• בחינת בתים. הנחת ערך על גבי מערך unsigned char[] מאפשרת לראות את הבתים הבודדים שלו, למשל כדי לקבוע את ה-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;
}

זה type punning: קריאה מכוונת של בתים כאילו הם מטיפוס אחר. קריאה דרך union בצורה כזו מותרת במפורש ב-C כתוצאה מוגדרת מימוש (בניגוד להמרת מצביעים בין טיפוסים לא קשורים, ששוברת את חוקי ה-aliasing), ובחינת בתים כ-unsigned char תמיד בטוחה. פירוש מחדש של int כ-float הוא סיפור אחר: התוצאה תלויה לגמרי בייצוג של הפלטפורמה שלכם, אז השאירו את זה מחוץ לקוד נייד.

טעויות נפוצות

• קריאת איבר שלא כתבתם אליו. הסכנה המרכזית. השתמשו בתגית.
• הנחה ש-union ממיר. הוא לא. u.i = 3; float f = u.f; מפרש ביטים מחדש; int i = 3; float f = i; ממיר. ראו type casting.
• הכנסת מצביע ל-union ואיבוד המעקב אחריו. אם ענף אחד מחזיק char * שהקציתם, דריסת ה-union באיבר אחר גורמת לדליפה: לא נשאר שום דבר שמצביע על ה-buffer. שחררו לפני שמחליפים ענף.
• ציפייה שהקומפיילר יבדוק. הוא לא יבדוק. unions הם אחד המאפיינים הבודדים ב-C שבהם השפה לא מציעה שום עזרה מעבר לגודל וליישור; התגית היא מעקה הבטיחות היחיד שלכם.