المؤشّر إلى بنية في لغة C: عامل السهم والبنى على الكومة

تُنسَخ البنية المُمرَّرة إلى دالة. وهذا مقبول لنقطة من عددين صحيحين ومهدر لسجلّ من مئتي بايت - كما يجعل التعديل مستحيلًا، لأن الدالة لا ترى إلا نسختها. والإشارة إلى بنية تحلّ المشكلتين معًا، وهي أيضًا الطريق الوحيد لبناء بنى تنمو: القوائم والأشجار والمخطّطات.

أخذ مؤشّر إلى بنية

لا يلزم شيء خاص. فـ & تعطيك العنوان، والنوع "مؤشّر إلى بنية":

#include <stdio.h>

struct Point {
    int x;
    int y;
};

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

    printf("x via struct : %d\n", p.x);
    printf("x via pointer: %d\n", (*ptr).x);
    printf("x via arrow  : %d\n", ptr->x);
    return 0;
}

تطبع الثلاثة كلها 3. والأخيرتان هما العملية نفسها مكتوبة بطريقتين.

لماذا تحتاج (*ptr).x إلى أقواسها

قد تحاول إسقاطها وتكتب *ptr.x. فتُترجَم إلى شيء مختلف تمامًا، أو ترفض الترجمة أصلًا في الأغلب - لأن عامل العضو . له أولوية أعلى من عامل المراجعة *:

*ptr.x        // parses as *(ptr.x)  -- wrong
(*ptr).x      // dereference first, then take the member -- correct
ptr->x        // the same thing, said shortly

تطلب ptr.x عضوًا من المؤشّر، والمؤشّر لا أعضاء له. وشكوى المترجم ("request for member 'x' in something not a structure or union") خطأ أولوية متنكّر.

ولأن تلك الصيغة المقوّسة قبيحة ويسهل الخطأ فيها، توفّر C العامل ->. وعمليًا لن ترى (*p).x في شيفرة حقيقية إلا نادرًا جدًا؛ فالجأ إلى p->x وانسَ أن الصيغة الطويلة موجودة، إلا بوصفها شرحًا لما يعنيه السهم.

تمرير بنية بالمؤشّر

يمنح وسيط المؤشّر الدالةَ بنيةَ المستدعي الفعلية، فتثبت التغييرات:

#include <stdio.h>

struct Point {
    int x;
    int y;
};

/* تعدّل بنية المستدعي. */
void translate(struct Point *p, int dx, int dy) {
    p->x += dx;
    p->y += dy;
}

/* تقرأ فقط - وconst تقول ذلك، والمترجم يفرضه. */
void print_point(const struct Point *p) {
    printf("(%d, %d)\n", p->x, p->y);
}

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

    print_point(&p);
    translate(&p, 10, -2);
    print_point(&p);
    return 0;
}

عادتان تستحقّان التكوين هنا:

• ضع const على مؤشّرات القراءة فقط. فـ const struct Point *p تعد بأن الدالة لن تغيّر ما تشير إليه p. فإن أضاف أحدهم لاحقًا p->x = 0 بالداخل، فشلت الترجمة بدلًا من شحن الخطأ. وهي توثّق القصد عند موضع الاستدعاء أيضًا.
• مرّر مؤشّرًا للبنى الكبيرة حتى عند القراءة. فبنية بمخزن اسم من 64 بايتًا تكلّف 64 بايتًا من النسخ لكل استدعاء بالقيمة؛ والمؤشّر يكلّف 8.

وتبقى البنى الصغيرة مقبولة للتمرير بالقيمة - فـ struct Point بثمانية بايتات تُنسَخ بالرخص نفسه الذي يُنسَخ به مؤشّر، والنسخة بالقيمة لا يمكن أن تكون NULL، ما يزيل نمط فشل بأكمله.

المؤشّرات داخل مصفوفات البنى

يعمل حساب المؤشّرات على مصفوفات البنى تمامًا كما يعمل على مصفوفات int: فـ p + 1 تتقدّم ببنية كاملة، بحشوها متضمّنًا.

#include <stdio.h>

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

double total_payroll(const struct Employee *staff, int n) {
    double total = 0.0;
    for (const struct Employee *e = staff; e < staff + n; e++) {
        total += e->salary;
    }
    return total;
}

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

    printf("Payroll: %.2f\n", total_payroll(staff, n));
    return 0;
}

يتحوّل اسم المصفوفة إلى مؤشّر إلى عنصرها الأول، فـ staff هي سلفًا struct Employee * عند الاستدعاء. ولهذا أيضًا تحتاج الدالة إلى تمرير n منفصلًا - إذ ستقيس sizeof داخل الدالة المؤشّرَ لا المصفوفة.

تخصيص بنية على الكومة

تموت بنى المكدّس في نهاية نطاقها. ولصنع واحدة تعمّر أطول من الدالة التي أنشأتها - أو لصنع ما يطلبه الإدخال منها - خصّص بـ malloc:

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

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

struct Employee *make_employee(int id, const char *name, double salary) {
    struct Employee *e = malloc(sizeof *e);
    if (e == NULL) {
        return NULL;            /* نفدت الذاكرة - على المستدعي الفحص */
    }
    e->id = id;
    snprintf(e->name, sizeof e->name, "%s", name);
    e->salary = salary;
    return e;
}

int main(void) {
    struct Employee *e = make_employee(101, "Ada", 92000.0);
    if (e == NULL) {
        fprintf(stderr, "allocation failed\n");
        return 1;
    }

    printf("%d %s %.2f\n", e->id, e->name, e->salary);

    free(e);
    return 0;
}

أربعة تفاصيل في تلك الدالة الصغيرة كلها حاملة للحمل:

• sizeof *e لا sizeof(struct Employee). تُقرأ "حجم ما تشير إليه e"، فإن تغيّر النوع يومًا تبعه التخصيص تلقائيًا. ولا سبيل لأن ينحرف الاثنان عن بعضهما.
• افحص NULL. تُرجِع malloc القيمة NULL حين تعجز عن تلبية الطلب. وكتابة e->id عبر مؤشّر فارغ خطأ تجزئة.
• هيّئ كل عضو. لا تصفّر malloc الذاكرة؛ فتصل البنية مليئة بالقمامة. (وcalloc(1, sizeof *e) تصفّرها نيابةً عنك.)
• على أحدهم تحريرها بـ free. فإرجاع مؤشّر مخصَّص ينقل ذلك الواجب إلى المستدعي. قُل ذلك في تعليق - فقاعدة الملكية غير الواضحة هي كيف تبدأ تسريبات الذاكرة.

المكسب: عقدة قائمة مترابطة

إليك ما لا تستطيع البنى فعله بلا مؤشّرات. فالبنية لا تستطيع احتواء نفسها - إذ ستكون لانهائية الحجم - لكنها تستطيع احتواء مؤشّر إلى واحدة من جنسها، وتلك الحيلة الواحدة تبني كل بنية بيانات مترابطة في C.

#include <stdio.h>
#include <stdlib.h>

struct Node {
    int value;
    struct Node *next;     /* مؤشّر إلى النوع نفسه مقبول */
};

/* تضيف عقدة إلى المقدّمة وتُرجِع الرأس الجديد. */
struct Node *push(struct Node *head, int value) {
    struct Node *n = malloc(sizeof *n);
    if (n == NULL) {
        return head;       /* نفدت الذاكرة: القائمة دون تغيير */
    }
    n->value = value;
    n->next = head;
    return n;
}

void print_list(const struct Node *head) {
    for (const struct Node *n = head; n != NULL; n = n->next) {
        printf("%d -> ", n->value);
    }
    printf("NULL\n");
}

void free_list(struct Node *head) {
    while (head != NULL) {
        struct Node *next = head->next;   /* احفظ قبل التحرير */
        free(head);
        head = next;
    }
}

int main(void) {
    struct Node *head = NULL;

    head = push(head, 3);
    head = push(head, 2);
    head = push(head, 1);

    print_list(head);
    free_list(head);
    return 0;
}

لاحظ أن struct Node *next; تشير إلى struct Node بينما ما تزال struct Node قيد التعريف. وهذا مشروع تحديدًا لأن للمؤشّر حجمًا معروفًا بصرف النظر عمّا يشير إليه - فالمترجم لا يحتاج إلى التعريف الكامل بعد. وهو أيضًا الموضع الوحيد الذي يجب فيه استخدام الوسم struct Node حتى لو كتبت typedef أيضًا: فاسم typedef لا يوجد بعد داخل تعريفه نفسه.

وتحفظ حلقة free_list القيمةَ head->next قبل استدعاء free(head). فقراءة head->next بعد التحرير استخدام بعد التحرير - إذ لم تعد الذاكرة ملكك، والقيمة التي تقرؤها هي ما وضعه المخصِّص هناك.

أخطاء شائعة

• p->x على مؤشّر غير مهيّأ أو NULL. أشيع سبب للانهيار في شيفرة كثيفة البنى. هيّئ المؤشّرات بـ NULL وافحص قبل المراجعة.
• إرجاع مؤشّر إلى بنية محلّية. فـ struct Point *bad(void) { struct Point p = {1,2}; return &p; } تُرجِع عنوان ذاكرة تكفّ عن الوجود لحظة عودة الدالة. أرجِع البنية بالقيمة، أو خصّصها.
• التحرير مرتين، أو نسيان التحرير. فكل malloc تقترن بـ free واحدة بالضبط. وبعد التحرير، اضبط المؤشّر على NULL ليتعطّل استخدام لاحق عرضي بصخب بدل إفساد الذاكرة بهدوء.
• نسخ بنية تحتوي على مؤشّر. فإسناد البنى ينسخ قيمة المؤشّر لا ما يشير إليه. وتشير البنيتان الآن إلى المخزن نفسه، وأيّهما حرّرته أولًا يترك الأخرى معلّقة.