calloc وrealloc في لغة C: ذاكرة مصفّرة وتكبير مصفوفة

يجيب malloc عن سؤال واحد: أعطني هذا العدد من البايتات. وثمّة رفيقان في <stdlib.h> يجيبان عن السؤالين التاليين - أعطني هذا العدد من البايتات، ممسوحة (calloc)، وأحتاج إلى أن تكبر الكتلة التي أملكها سلفًا (realloc).

calloc: عدد وحجم وأصفار

void *calloc(size_t count, size_t size);

وسيطان بدل واحد، والنتيجة مملوءة ببايتات صفرية.

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

int main(void) {
    size_t n = 6;

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

    /* أصفار سلفًا - لا حاجة إلى حلقة تهيئة */
    for (size_t i = 0; i < n; i++) {
        printf("%d ", counts[i]);
    }
    printf("\n");

    counts[2] += 1;
    counts[2] += 1;
    printf("counts[2] = %d\n", counts[2]);

    free(counts);
    return 0;
}

تلك هي الحالة الكلاسيكية: مدرّج تكراري أو مصفوفة إحصاء يجب أن يبدأ كل موضع فيها من الصفر. مع malloc كنت ستحتاج إلى حلقة؛ أما calloc فتفعل ذلك كجزء من التخصيص، وغالبًا بلا كلفة لأن نظام التشغيل يسلّم أصلًا صفحات جديدة مصفّرة مسبقًا.

حجّة الفيضان

تقسيم الوسائط إلى اثنين ليس تجميليًا. تأمّل عددًا مقروءًا من ملف:

size_t n = huge_value_from_input;

int *a = malloc(n * sizeof *a);     /* يمكن أن يلتفّ الحاصل */
int *b = calloc(n, sizeof *b);      /* مطلوب منها اكتشاف الفيضان */

إن تجاوز n * sizeof *a ما يستطيع size_t حمله، فإنه يلتفّ إلى عدد صغير، فينجح malloc بكتلة ضئيلة، وتمضي كل كتابة لاحقة بعيدًا بعد النهاية. أما calloc فالمعيار يلزمها بالفشل وإعادة NULL بدلًا من ذلك. وعندما يأتي الحجم من خارج برنامجك، فذلك الفحص يستحقّ الاقتناء.

ما الذي يعنيه "مصفّرة" فعلًا

تكتب calloc بايتات صفرية. وبالنسبة للأعداد الصحيحة والمحارف تكون تلك هي القيمة صفر، وهو ما تريده. أما للمؤشّرات وقيم الفاصلة العائمة، فكون البتّات كلها أصفارًا يعني مؤشّرًا فارغًا و0.0 على كل منصّة رئيسية، لكن معيار C لا يَعِد بذلك. والشيفرات التي يجب أن تكون محمولة بصرامة تُسنِد تلك القيم صراحةً.

calloc مقابل malloc مع memset

int *a = calloc(n, sizeof *a);

int *b = malloc(n * sizeof *b);
if (b != NULL) {
    memset(b, 0, n * sizeof *b);
}

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

realloc: تغيير الحجم

void *realloc(void *p, size_t newsize);

تُعيد realloc كتلة بحجم newsize بايت تطابق محتوياتها الكتلة القديمة حتى أصغر الحجمين. وقد توسّع الكتلة في موضعها، أو تخصّص كتلة جديدة وتنسخ وتحرّر القديمة. ولا يمكنك معرفة أيهما حدث، لذا فإن المؤشّر الوحيد الذي يجوز لك استخدامه بعدها هو ذاك الذي أعادته.

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

int main(void) {
    size_t n = 3;
    int *a = malloc(n * sizeof *a);
    if (a == NULL) {
        return 1;
    }
    for (size_t i = 0; i < n; i++) {
        a[i] = (int)i;
    }

    size_t bigger = 6;
    int *tmp = realloc(a, bigger * sizeof *a);
    if (tmp == NULL) {
        free(a);                 /* a ما زالت صالحة - حرّرها */
        fprintf(stderr, "grow failed\n");
        return 1;
    }
    a = tmp;

    /* القيم الثلاث الأولى نجت؛ والمواضع الجديدة غير مهيّأة */
    for (size_t i = n; i < bigger; i++) {
        a[i] = (int)(i * 10);
    }

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

    free(a);
    return 0;
}

صيغة المؤشّر tmp

الأسطر الثلاثة المحيطة بـ tmp هي السبب الكامل لسمعة هذه الدالة. فالاختصار المغري معطوب:

/* BUG: leaks the original block when realloc fails */
p = realloc(p, newsize);
if (p == NULL) {
    return;
}

عندما تفشل realloc تُعيد NULL وتترك الكتلة الأصلية مخصّصة ودون تغيير. وإسناد النتيجة مباشرة إلى p يكتب فوق المؤشّر الوحيد إلى تلك الكتلة، فلا يمكن تحريرها أبدًا - تسريب، ويحدث بالضبط حين تكون الذاكرة شحيحة أصلًا. أسنِد إلى tmp، وافحص tmp، ثم اعتمد النتيجة:

void *tmp = realloc(p, newsize);
if (tmp == NULL) {
    /* p ما زالت صالحة؛ عالج الفشل بما يناسب المستدعي */
    return 0;
}
p = tmp;

وثمّة سلوكان آخران يستحقّان المعرفة: realloc(NULL, n) تتصرّف تمامًا مثل malloc(n)، وهو ما يتيح لدالة نمو أن تعالج استدعاءها الأول دون حالة خاصة. والتكبير يترك البايتات الجديدة غير مهيّأة - فالمحفوظ هو المحتوى القديم فقط.

تكبير مصفوفة: النمط القياسي

إليك النمط الذي تستخدمه كل حاوية في C تقريبًا - طول وسعة ومضاعفة عند تلاقيهما.

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

struct IntVec {
    int   *data;
    size_t len;
    size_t cap;
};

/* تُعيد 1 عند النجاح و0 إن تعذّر نمو المصفوفة */
int vec_push(struct IntVec *v, int value) {
    if (v->len == v->cap) {
        size_t newcap = (v->cap == 0) ? 4 : v->cap * 2;

        int *tmp = realloc(v->data, newcap * sizeof *v->data);
        if (tmp == NULL) {
            return 0;               /* v->data لم تُمسّ وما زالت صالحة */
        }
        v->data = tmp;
        v->cap  = newcap;
    }

    v->data[v->len++] = value;
    return 1;
}

int main(void) {
    struct IntVec v = {NULL, 0, 0};

    for (int i = 1; i <= 10; i++) {
        if (!vec_push(&v, i * i)) {
            fprintf(stderr, "out of memory at %d\n", i);
            free(v.data);
            return 1;
        }
    }

    printf("len = %zu, cap = %zu\n", v.len, v.cap);
    for (size_t i = 0; i < v.len; i++) {
        printf("%d ", v.data[i]);
    }
    printf("\n");

    free(v.data);
    v.data = NULL;
    v.len = v.cap = 0;
    return 0;
}

نقطتان تصميميتان تحملان الثقل هنا.

المضاعفة، لا الزيادة بواحد. النمو بمقدار ثابت يجعل كل إضافة تنسخ المصفوفة كاملة، فيكلّف ملء n عنصرًا نحو n² من نسخ البايتات. أما المضاعفة فتجعل النسخ نادرًا بما يكفي ليكلّف كل إدخال زمنًا ثابتًا في المتوسط. والبداية cap == 0 ? 4 : cap * 2 تعالج الإدخال الأول دون فرع منفصل، لأن realloc(NULL, n) ليست سوى malloc.

البنية تملك تخصيصًا واحدًا. تُحرَّر v.data مرة واحدة بالضبط، على يد من يملك البنية. وكتابة قاعدة الملكية تلك - في تعليق، أو بإقران كل vec_init بـ vec_free - هي ما يمنع حاوية نامية من التسريب وهي تتنقّل بين الدوال.

التصغير

realloc بحجم أصغر تقلّم الكتلة، وهو مفيد بعد أن تكون قد قرأت كمية غير معروفة من البيانات في مخزن أكبر من اللازم:

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

int main(void) {
    size_t cap = 1024;
    char *buf = malloc(cap);
    if (buf == NULL) {
        return 1;
    }

    const char *text = "only a few bytes";
    size_t used = 0;
    while (text[used] != '\0' && used < cap - 1) {
        buf[used] = text[used];
        used++;
    }
    buf[used] = '\0';

    char *tmp = realloc(buf, used + 1);
    if (tmp != NULL) {
        buf = tmp;               /* نجح التصغير */
    }
    /* إن فشل، تبقى buf هي الكتلة الأكبر - وصالحة للاستخدام تمامًا */

    printf("[%s] now sized %zu\n", buf, used + 1);

    free(buf);
    return 0;
}

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

أيّها تختار

وكلها تُحرَّر بـ free نفسها، مرة واحدة بالضبط.

أخطاء شائعة

• p = realloc(p, n) - تسرّب عند الفشل. مُرّ دائمًا عبر tmp.
• الاحتفاظ بمؤشّر قديم داخل الكتلة. بعد realloc قد تكون البيانات قد انتقلت، فيصبح كل مؤشّر داخلي محفوظ أو عنوان مشتقّ من فهرس قديمًا لا معنى له. الفهارس تنجو من الانتقال؛ أما المؤشّرات فلا.
• افتراض أن البايتات الجديدة أصفار. calloc وحدها تصفّر. أما realloc فتترك منطقة النمو غير مهيّأة.
• calloc(n * size, 1) - هذا يرمي فحص الفيضان الذي وُجدت الصيغة ذات الوسيطين من أجله.
• تحرير المؤشّر القديم بعد نجاح realloc. لقد حرّرته realloc سلفًا؛ وfree ثانية تحرير مزدوج.