malloc في لغة C: تخصيص الذاكرة الديناميكي وfree وsizeof

كل مصفوفة كتبتها حتى الآن كان حجمها مخبوزًا وقت الترجمة: فـ int scores[10]; يحجز عشرة مواضع سواء احتجت ثلاثة أم ثلاثمئة. وينجح ذلك حتى يصير الحجم معروفًا فقط أثناء تشغيل البرنامج - كم سطرًا في ملف، وكم سجلًّا أدخل المستخدم. والذاكرة الديناميكية تحلّ ذلك: تطلب البايتات التي تحتاجها، حين تحتاجها، وتعيدها حين تنتهي.

والأدوات في <stdlib.h>:

#include <stdlib.h>

لماذا توجد الكومة

تمنح C برنامجك منطقتين رئيسيتين من الذاكرة. المتغيّرات المحلية تعيش في التخزين التلقائي (المكدّس): يقرّر المترجم حجمها، وتزول لحظة عودة دالتها. أما التخصيصات الديناميكية فتعيش في الكومة: تقرّر الحجم أنت أثناء التشغيل، وتبقى الكتلة حيّة حتى تحرّرها صراحةً.

وتلك الخاصية الثانية هي السبب الحقيقي لاستخدام malloc. فيمكن لدالة أن تخصّص كتلة وتُعيد المؤشّر، وتبقى الذاكرة صالحة لدى المستدعي - وهو ما لا تستطيعه مصفوفة محلية أبدًا. والمنطقتان مقارنتان بالتفصيل في المكدّس مقابل الكومة.

malloc: طلب البايتات

يأخذ malloc عدد بايتات ويُعيد void * يشير إلى ذلك العدد من بايتات الذاكرة غير المهيّأة، أو NULL إن فشل الطلب.

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

int main(void) {
    int n = 5;

    int *scores = malloc(n * sizeof *scores);
    if (scores == NULL) {
        fprintf(stderr, "out of memory\n");
        return 1;
    }

    for (int i = 0; i < n; i++) {
        scores[i] = (i + 1) * 10;
    }

    for (int i = 0; i < n; i++) {
        printf("scores[%d] = %d\n", i, scores[i]);
    }

    free(scores);
    scores = NULL;
    return 0;
}

أربعة أشياء في ذلك البرنامج القصير هي الانضباط كله:

1. تعبير الحجم هو n * sizeof *scores. اقرأه على أنه "n من أيًّا كان ما تشير إليه scores".
2. تُفحَص النتيجة مقابل NULL قبل أي استخدام.
3. تُستخدَم الكتلة تمامًا كمصفوفة - فـ scores[i] تعمل لأن الفهرسة حساب مؤشّرات.
4. تُحرَّر مرة واحدة، ثم يُضبَط المؤشّر على NULL.

لاحظ أنه لا تحويل على القيمة المُعادة. ففي C يُحوَّل void * إلى أي مؤشّر كائن تلقائيًا، وكتابة (int *)malloc(...) تضيف ضجيجًا وتخفي غياب تضمين <stdlib.h>. (و++C تتطلّب التحويل؛ أما C فلا.)

صيغة sizeof

لماذا sizeof *scores بدل sizeof(int)؟ لأنها لا يمكن أن تتقادم.

int  *a = malloc(n * sizeof *a);     /* n من الأعداد الصحيحة، أيًّا كان int هنا */
long *b = malloc(n * sizeof *b);     /* شكل السطر نفسه، والحجم صحيح */

/* الصيغة الهشّة */
long *c = malloc(n * sizeof(int));   /* تُترجَم، وتخصّص أقلّ من اللازم */

السطر الأخير علّة حقيقية لا يحذّر منها أي مترجم: فـ c من نوع long *، والتخصيص محسوب على مقاس int، وكل كتابة بعد النصف الأول تخرج عن النهاية. ومع sizeof *c يتبع الحجم التعريف تلقائيًا.

وsizeof *p لا تفكّ إشارة p - فـ sizeof تُقيَّم وقت الترجمة من النوع وحده، فهي آمنة حتى حين يكون p غير مهيّأ أو NULL.

الذاكرة غير المهيّأة

لا يمسح malloc ما يعطيك إياه. فالبايتات تحمل ما كان فيها من قبل.

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

int main(void) {
    int *p = malloc(4 * sizeof *p);
    if (p == NULL) {
        return 1;
    }

    /* القراءة قبل الكتابة سلوك غير معرَّف - فاكتب أولًا */
    for (int i = 0; i < 4; i++) {
        p[i] = 0;
    }

    printf("%d %d %d %d\n", p[0], p[1], p[2], p[3]);

    free(p);
    return 0;
}

وحين تريد الكتلة مصفّرة نيابةً عنك، يفعل calloc ذلك في خطوة واحدة - انظر calloc وrealloc.

free: إعادتها

يُعيد free(p) الكتلة إلى المخصّص. وثلاث قواعد:

• مرّر المؤشّر المضبوط الذي أعاده malloc، لا واحدًا تقدّم. فـ free(p + 1) سلوك غير معرَّف.
• حرّر كل كتلة مرة واحدة بالضبط. ومرتين تحرير مزدوج، يُفسد سجلّات المخصّص نفسها.
• بعد التحرير يصبح المؤشّر متقادمًا. واستخدامه استخدام بعد التحرير.

int *p = malloc(sizeof *p);
free(p);
*p = 5;        /* استخدام بعد التحرير - سلوك غير معرَّف */
free(p);       /* تحرير مزدوج - سلوك غير معرَّف */

ولا يلزم أن ينهار أي من السطرين فورًا، وهذا ما يجعلهما خطرين: فقد يعمل البرنامج دقائق ثم يفشل في مكان لا علاقة له. والدفاع الرخيص هو تفريغ المؤشّر:

free(p);
p = NULL;

free(NULL) معرَّفة صراحةً بأنها لا تفعل شيئًا، فتصبح free(p) ثانية بعدها غير ضارّة، وتصير *p انهيارًا فوريًا عند موضع الخطأ الحقيقي بدل إفساد صامت.

مصفوفة ديناميكية من البداية إلى النهاية

إليك شكل تخصيص حقيقي: اقرأ عددًا أثناء التشغيل، وحدّد حجم الكتلة منه، واستخدمها، وحرّرها.

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

int main(void) {
    int n = 8;   /* تخيّل أن هذا جاء من إدخال أو ملف */

    double *values = malloc((size_t)n * sizeof *values);
    if (values == NULL) {
        fprintf(stderr, "allocation of %d doubles failed\n", n);
        return 1;
    }

    for (int i = 0; i < n; i++) {
        values[i] = 1.0 / (i + 1);
    }

    double sum = 0.0;
    for (int i = 0; i < n; i++) {
        sum += values[i];
    }

    printf("sum of 1/1 .. 1/%d = %f\n", n, sum);
    printf("block holds %zu bytes\n", (size_t)n * sizeof *values);

    free(values);
    values = NULL;
    return 0;
}

والتحويل إلى size_t على العدّاد يهمّ بمجرّد أن تكبر الأحجام: فـ n * sizeof *values مع n من نوع int عادي يمكن أن يفيض قبل أن يصل حاصل الضرب إلى malloc أصلًا، فيُنتج كتلة أصغر بكثير من المقصود. والضرب في size_t يتجنّب ذلك.

التخصيص داخل دالة

قاعدة عمر الكومة هي ما يجعل هذا مسموحًا - وما يجعل إعادة مصفوفة محلية ممنوعة:

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

/* المستدعي يملك الكتلة المُعادة وعليه تحريرها */
char *duplicate(const char *text) {
    size_t len = strlen(text);
    char *copy = malloc(len + 1);
    if (copy == NULL) {
        return NULL;
    }
    memcpy(copy, text, len + 1);
    return copy;
}

int main(void) {
    char *greeting = duplicate("hello, heap");
    if (greeting == NULL) {
        fprintf(stderr, "out of memory\n");
        return 1;
    }

    greeting[0] = 'H';
    printf("%s\n", greeting);

    free(greeting);
    return 0;
}

تترك len + 1 مكانًا لمحرف الإنهاء الصفري - وهي قاعدة التحجيم نفسها في كل مكان في السلاسل النصية. ولاحظ التعليق فوق الدالة: فحين تُعيد دالة ذاكرة مخصّصة، يكون من يحرّرها جزءًا من عقدها. وكتابة ذلك ليست بيروقراطية؛ بل هي الشيء الوحيد الذي يمنع تسريبًا.

البنى على الكومة

الصيغة نفسها تعمل لأي نوع:

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

struct Point {
    double x;
    double y;
};

int main(void) {
    struct Point *p = malloc(sizeof *p);
    if (p == NULL) {
        return 1;
    }

    p->x = 3.0;
    p->y = 4.0;
    printf("(%.1f, %.1f)\n", p->x, p->y);

    /* مصفوفة منها */
    int n = 3;
    struct Point *path = malloc((size_t)n * sizeof *path);
    if (path == NULL) {
        free(p);
        return 1;
    }

    for (int i = 0; i < n; i++) {
        path[i].x = i;
        path[i].y = i * i;
    }
    printf("last point: (%.1f, %.1f)\n", path[n - 1].x, path[n - 1].y);

    free(path);
    free(p);
    return 0;
}

لاحظ أن فرع الفشل الثاني يحرّر p قبل العودة. فبمجرّد أن تحمل دالة أكثر من تخصيص واحد، يجب على كل مسار خطأ تحرير ما أُخذ سلفًا - وهو أشيع مصدر للتسريبات الموصوفة في تسريبات الذاكرة.

قائمة تحقّق

• افحص دائمًا malloc بحثًا عن NULL قبل أول استخدام.
• حدّد الحجم بـ n * sizeof *p، مع الضرب في size_t.
• لا تحويل على القيمة المُعادة في C.
• ذاكرة malloc غير مهيّأة؛ فاكتب قبل أن تقرأ.
• حرّر مرة واحدة بالضبط، بالمؤشّر الأصلي، ثم اضبطه على NULL.
• كل مسار خطأ بعد تخصيص يجب أن يحرّر ما يحمله سلفًا.