الاتّحاد في لغة C: الذاكرة المشتركة والاتّحاد مقابل البنية والاتّحادات الموسومة

تقول البنية "كل هذه معًا". ويقول union "واحد من هذه بالضبط، في كل مرة". فالأعضاء موضوعون بعضهم فوق بعض في العنوان نفسه، فلا يكون الاتّحاد أكبر من أكبر أعضائه والكتابة في عضو تدمّر الآخرين.

ويبدو ذلك فخًّا، وهو كذلك إن تُرك دون ضبط. لكنه أيضًا كيف تعبّر C عن قيمة قد تكون من عدة أنواع - رمز هو عدد أو سلسلة نصية، ورسالة هي نقرة أو ضغطة مفتاح - دون دفع ثمنها كلها دفعة واحدة.

تعريف اتّحاد واستخدامه

تعكس الصياغة البنية تمامًا؛ ولا تتغيّر إلا الكلمة المفتاحية.

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

يُوصَل إلى الأعضاء بـ . (أو -> عبر مؤشّر)، تمامًا كما مع بنية. والمختلف أن العضو المكتوب أحدثَ الكتابة وحده يحمل قيمة ذات معنى. فبعد v.f = 3.5f، لا تعطيك قراءة v.i القيمة 3 - بل تعطيك أي عدد صحيح يصادف أن يهجئه نمط بتات 3.5f.

الحجم: أكبر عضو يفوز

قارن توزيع الذاكرة لبنية واتّحاد بالأعضاء نفسها:

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

على جهاز نموذجي تكون البنية 24 بايتًا (4 للعدد الصحيح، و8 للعدد العشري، و1 للمحرف، زائد الحشو) بينما يكون الاتّحاد 8 - حجم double فيه، مقرَّبًا لأعلى للمحاذاة. والعناوين الثلاثة المطبوعة متطابقة، وهذه هي قصة الاتّحادات كلها في سطر خرج واحد.

ولاحظ تحويلات %p إلى void *. فـ printf تتوقّع ذلك بالضبط لأجل %p؛ وتمرير نوع مؤشّر مختلف سلوك غير معرَّف وإن بدا عاملًا عادةً. انظر محدّدات التنسيق.

تهيئة اتّحاد

مهيّئ بأقواس معقوفة بلا مسمٍّ يهيّئ العضو الأول:

#include <stdio.h>

union Value {
    int i;
    float f;
};

int main(void) {
    union Value a = {42};              /* تهيّئ .i، العضو الأول */
    union Value b = {.f = 3.5f};       /* مسمّى: يهيّئ .f */

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

والصيغة المسمّاة هي ما ينبغي استخدامه. فـ {42} تعتمد بصمت على ترتيب الأعضاء، فإعادة ترتيب التعريف لاحقًا تغيّر أي عضو يُهيَّأ - وهو خطأ خبيث فعلًا، لأن لا شيء في الشيفرة يبدو مختلفًا.

المشكلة الحقيقية: أي عضو حيّ؟

لا يسجّل الاتّحاد أي عضو كتبته آخرًا. فهو مجرّد بايتات؛ والمعرفة تعيش في رأسك، وهذا بالضبط حيث تضيع المعرفة.

#include <stdio.h>

union Value {
    int i;
    float f;
};

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

    /* قراءة .i الآن تعيد تفسير بتات العدد العشري كعدد صحيح. */
    printf("wrote 1.0f, read back as int: %d\n", v.i);
    return 0;
}

الرقم المطبوع كبير وغريب - نمط بتات 1.0f مقروءًا كـ int. لم ينهر شيء ولم يحذّر شيء، والبرنامج خاطئ بهدوء. فقد فعل الاتّحاد بالضبط ما وعد به؛ وكان الخطأ خطأنا في نسيان أي عضو كان حيًّا.

الحلّ: اتّحاد موسوم

الحلّ المعياري هو قرن الاتّحاد بـتعداد يسجّل العضو الحيّ، وتغليف الاثنين في بنية. ويُسمّى ذلك المزيج اتّحادًا موسومًا (أو اتّحادًا مميَّزًا)، وهو كيف ينبغي أن تكتب كل اتّحاد في شيفرة التطبيقات عمليًا.

#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 لبنية تحمل الثلاثة. ومع مئة ألف منها، يهمّ ذلك.

والترجمة بـ -Wall تضيف شبكة أمان ثانية: فإن أضفت لاحقًا VAL_BOOL إلى التعداد ونسيت case له، حذّرك GCC من قيمة التعداد غير المعالَجة.

الاتّحادات مجهولة الاسم

تسمح C11 بعضو اتّحاد بلا اسم داخل بنية، فترقّي أعضاءه إلى فضاء أسماء البنية الخارجية:

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

ولأن الاتّحاد نفسه بلا اسم، تكتب s->circle.r بدل s->as.circle.r. أقصر قراءةً، بثمن إخفاء وجود اتّحاد أصلًا - وهو مقبول حين يكون الوسم بجواره مباشرةً.

أين تكسب الاتّحادات قيمتها فعلًا

أربعة استخدامات متكرّرة:

• القيم المتغايرة. المفسّرات، ومحلّلات JSON والتهيئة، وطوابير الرسائل، كلها تحمل قيمًا يُحدَّد نوعها في وقت التشغيل. والاتّحاد الموسوم هو التمثيل النموذجي.
• السجلّات الضيّقة الذاكرة. حين تحمل بنية عدة حقول يستبعد بعضها بعضًا وتملك ملايين منها، يكون تراكبها توفيرًا مباشرًا.
• توزيعات البروتوكولات والعتاد. فحزمة تعتمد حمولتها على بايت ترويسة تنطبق طبيعيًا على اتّحاد موسوم، وكذلك سجلّات الأجهزة.
• فحص البايتات. فتراكب قيمة مع مصفوفة unsigned char[] يتيح لك النظر في بايتاتها المفردة، مثلًا لتحديد ترتيب البايتات:

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

وهذا إعادة تفسير للنوع - أي قراءة البايتات عمدًا بنوع مختلف. والقراءة عبر اتّحاد بهذه الطريقة مسموح بها صراحةً كنتيجة يحدّدها التطبيق في C (بخلاف تحويل المؤشّرات بين أنواع غير مترابطة، وهو ما يكسر قواعد التسمية المستعارة)، وفحص البايتات كـ unsigned char آمن دائمًا. أما إعادة تفسير int كـ float فمسألة أخرى: فالنتيجة تعتمد كليًا على تمثيل منصّتك، فأبقِها خارج الشيفرة القابلة للنقل.

أخطاء شائعة

• قراءة عضو لم تكتبه. الخطر الرئيسي. استخدم وسمًا.
• افتراض أن الاتّحاد يحوّل. إنه لا يفعل. فـ u.i = 3; float f = u.f; تعيد تفسير البتات؛ وint i = 3; float f = i; تحوّل. انظر تحويل الأنواع.
• وضع مؤشّر في اتّحاد وفقدان أثره. فإن حمل أحد الفروع مؤشّر char * خصّصته، فإن الكتابة فوق الاتّحاد بعضو مختلف تسرّبه - فلا يبقى شيء يشير إلى المخزن. حرّر قبل تبديل الفروع.
• توقّع أن يفحص المترجم. لن يفعل. فالاتّحادات من الخصائص القليلة في C التي لا تقدّم فيها اللغة أي مساعدة تتجاوز الحجم والمحاذاة؛ والوسم حاجزك الوحيد.