البنى في لغة C: التعريف والتهيئة والاستخدام

تحمل المصفوفة قيمًا كثيرة من نوع واحد. وتفعل struct العكس: تحمل بضع قيم من أنواع مختلفة وتعاملها كشيء واحد. فالنقطة هي x وy. والموظّف اسم ومعرّف وراتب. وبدون البنى كنت ستحمل تلك حولك كثلاثة متغيّرات سائبة وترجو ألّا تخلط بين رواتب الناس.

تعريف نوع بنية

يسمّي تعريف البنية وسمًا ويُدرِج الأعضاء بين أقواس معقوفة:

struct Point {
    int x;
    int y;
};

والفاصلة المنقوطة بعد القوس المغلق مطلوبة - ونسيانها من أكثر رسائل الأخطاء إرباكًا لمبتدئ C، لأن المترجم يلوم السطر التالي.

وهذا يعرّف نوعًا لا متغيّرًا. وفي C يكون الاسم الكامل للنوع struct Point، متضمّنًا الكلمة المفتاحية:

#include <stdio.h>

struct Point {
    int x;
    int y;
};

int main(void) {
    struct Point p;
    p.x = 3;
    p.y = 4;

    printf("(%d, %d)\n", p.x, p.y);
    return 0;
}

تُقرأ الأعضاء وتُكتب بـ عامل النقطة، p.x. ومتغيّر البنية متغيّر عادي: يعيش على المكدّس، ويمكن إسناده إلى بنية أخرى من النوع نفسه بـ =، ويختفي في نهاية نطاقه.

وكتابة struct Point في كل مكان تُتعب، ولهذا تغلّف معظم شيفرة C الحقيقية التعريفَ بـtypedef ليصبح النوع ببساطة Point.

تهيئة بنية

يمكنك ملء بنية لحظة تعريفها. وتُدرِج الصيغة الموضعية القيم بترتيب التعريف:

struct Point p = {3, 4};   // x = 3, y = 4

أما المهيّئ المسمّى فيسمّي كل عضو بدلًا من ذلك، وهو أوضح وأكثر أمانًا:

#include <stdio.h>

struct Employee {
    int id;
    char name[32];
    double salary;
};

int main(void) {
    struct Employee a = {101, "Ada", 92000.0};
    struct Employee b = {.name = "Grace", .id = 102, .salary = 105000.0};
    struct Employee blank = {0};

    printf("%d %s %.2f\n", a.id, a.name, a.salary);
    printf("%d %s %.2f\n", b.id, b.name, b.salary);
    printf("%d [%s] %.2f\n", blank.id, blank.name, blank.salary);
    return 0;
}

ثلاثة أمور تستحق الملاحظة:

• تستطيع الصيغة المسمّاة إدراج الأعضاء بأي ترتيب، فإضافة عضو أو إعادة ترتيبه لاحقًا لا تزيح القيم بصمت إلى الخانات الخاطئة.
• أي عضو تتركه يُهيَّأ بصفر - و{0} هي الطريقة الاصطلاحية لتصفير بنية كاملة.
• والعضو char name[32] مصفوفة حقيقية داخل البنية، فالسلسلة مخزَّنة في البنية نفسها لا في مكان آخر. وهذا يعني أيضًا أن a.name = "Ada"; بعد ذلك غير مشروعة؛ إذ تحتاج إلى strcpy (انظر دوال السلاسل النصية).

والبنية بلا مهيّئ تكون غير مهيّأة، وقراءة أعضائها قبل الكتابة فيها سلوك غير معرَّف. و= {0} لا تكلّف شيئًا وتزيل هذا الصنف من الأخطاء بأكمله.

الإسناد والمقارنة

إسناد البنى ينسخ كل عضو:

#include <stdio.h>

struct Point {
    int x;
    int y;
};

int main(void) {
    struct Point a = {1, 2};
    struct Point b = a;   // نسخة كاملة

    b.x = 99;

    printf("a = (%d, %d)\n", a.x, a.y);
    printf("b = (%d, %d)\n", b.x, b.y);
    return 0;
}

a دون مساس: فقد حصلت b على نسختها. لكن لاحظ ما لا تمنحك إياه C - فلا يوجد == للبنى. وif (a == b) لن تُترجَم. والمقارنة تعني مقارنة الأعضاء:

if (a.x == b.x && a.y == b.y) { /* equal */ }

ولا تلجأ إلى memcmp كاختصار. فالمترجمات تُدرِج بايتات حشو غير مرئية بين الأعضاء للمحاذاة، وقد تحمل تلك البايتات قمامة، فبنيتان بأعضاء متطابقة قد تختلفان بايتًا ببايت.

مصفوفات البنى

ولأن البنية نوع كأي نوع آخر، يمكنك إنشاء مصفوفة منها - وهي الطريقة المعيارية للاحتفاظ بجدول من السجلّات.

#include <stdio.h>

struct Employee {
    int id;
    char name[32];
    double salary;
};

int main(void) {
    struct Employee staff[3] = {
        {101, "Ada",    92000.0},
        {102, "Grace",  105000.0},
        {103, "Alan",   87000.0},
    };

    int n = sizeof(staff) / sizeof(staff[0]);
    double total = 0.0;

    for (int i = 0; i < n; i++) {
        printf("%-3d %-8s %10.2f\n", staff[i].id, staff[i].name, staff[i].salary);
        total += staff[i].salary;
    }

    printf("Average: %.2f\n", total / n);
    return 0;
}

تُقرأ staff[i].salary هكذا: "العنصر i، ثم عضوه salary" - فالفهرسة ترتبط أوثق من النقطة، فلا حاجة إلى أقواس.

تُنسَخ البنى إلى الدوال

هذه هي القاعدة التي توقع بالناس. فحين تمرّر بنية إلى دالة، تنسخها C. وتعمل الدالة على نسختها الخاصة:

#include <stdio.h>

struct Point {
    int x;
    int y;
};

void try_to_move(struct Point p) {
    p.x += 100;   // تغيّر النسخة فقط
}

double distance_from_origin(struct Point p) {
    return p.x * p.x + p.y * p.y;   // المسافة التربيعية، بلا حاجة إلى math.h
}

int main(void) {
    struct Point p = {3, 4};

    try_to_move(p);
    printf("after try_to_move: (%d, %d)\n", p.x, p.y);
    printf("squared distance: %.0f\n", distance_from_origin(p));
    return 0;
}

p ما تزال (3, 4). وقراءة بنية بالقيمة، كما تفعل distance_from_origin، مقبولة تمامًا وكثيرًا ما تكون الخيار الأوضح للبنى الصغيرة. لكن إن كان على الدالة تغيير بنية المستدعي - أو إن كانت البنية كبيرة إلى حدّ يجعل نسخها إهدارًا - فمرّر مؤشّرًا بدلًا من ذلك. وذلك موضوع البنى والمؤشّرات.

وإرجاع بنية بالقيمة يعمل بالطريقة نفسها وهو مشروع تمامًا:

struct Point make_point(int x, int y) {
    struct Point p = {x, y};
    return p;
}

البنى المتداخلة

يمكن أن يكون عضو البنية بنية بدوره. اربط النقاط للوصول إلى الداخل:

#include <stdio.h>

struct Date {
    int year;
    int month;
    int day;
};

struct Book {
    char title[64];
    struct Date published;
    int pages;
};

int main(void) {
    struct Book b = {
        .title = "The C Programming Language",
        .published = {.year = 1978, .month = 2, .day = 22},
        .pages = 228,
    };

    printf("%s (%d-%02d-%02d), %d pages\n",
           b.title,
           b.published.year, b.published.month, b.published.day,
           b.pages);
    return 0;
}

تدخل b.published.year مستوى واحدًا في كل مرة. والتداخل هو كيف تبني نماذج بيانات حقيقية في C - والبنية الداخلية مخزَّنة داخل الخارجية لا مشارًا إليها، فـ Book كلها كتلة ذاكرة متّصلة واحدة.

الحجم والحشو وترتيب الأعضاء

تخبرك sizeof بحجم البنية، والإجابة أكبر غالبًا من مجموع أعضائها:

#include <stdio.h>

struct Wasteful {
    char  a;    // بايت واحد
    int   b;    // 4 بايتات
    char  c;    // بايت واحد
};

struct Tidy {
    int   b;
    char  a;
    char  c;
};

int main(void) {
    printf("Wasteful: %zu bytes\n", sizeof(struct Wasteful));
    printf("Tidy:     %zu bytes\n", sizeof(struct Tidy));
    return 0;
}

على جهاز نموذجي تكون Wasteful اثني عشر بايتًا وTidy ثمانية، رغم أن كلتيهما تحمل الأعضاء الثلاثة نفسها. فالمترجم يُدرِج حشوًا ليقع كل عضو في عنوان يحبّه نوعه - فـ int يريد عادةً مضاعفًا لأربعة. وتجميع الأعضاء الأكبر قبل الأصغر يميل إلى رصّ أفضل.

ويهمّ هذا نادرًا (مصفوفة بمليون عنصر، أو توزيع حزمة شبكة) ولا يهمّ أبدًا لصحّة شيفرتك. وما يفسّره فعلًا هو سبب مفاجأة sizeof لك، وسبب كون memcmp على البنى فكرة سيئة.