malloc ב-C: הקצאת זיכרון דינמית, free ו-sizeof

לכל מערך שכתבתם עד עכשיו היה גודל שנקבע בזמן קומפילציה: int scores[10]; שומר עשרה תאים בין אם צריך שלושה או שלוש מאות. זה עובד עד שהגודל ידוע רק בזמן שהתוכנית רצה: כמה שורות יש בקובץ, כמה רשומות המשתמש מזין. זיכרון דינמי פותר את זה: מבקשים את הבתים שצריך, כשצריך אותם, ומחזירים אותם כשמסיימים.

הכלים נמצאים ב-<stdlib.h>:

#include <stdlib.h>

למה ה-heap קיים

C נותנת לתוכנית שלכם שני אזורי זיכרון עיקריים. משתנים מקומיים חיים באחסון אוטומטי (המחסנית, stack): הקומפיילר מחליט על הגודל שלהם, והם נעלמים ברגע שהפונקציה שלהם מסתיימת. הקצאות דינמיות חיות ב-heap: אתם מחליטים על הגודל בזמן ריצה, והבלוק נשאר חי עד שמשחררים אותו במפורש.

התכונה השנייה הזו היא הסיבה האמיתית להשתמש ב-malloc. פונקציה יכולה להקצות בלוק, להחזיר את המצביע, והזיכרון עדיין תקף אצל מי שקרא לה, משהו שמערך מקומי לעולם לא יכול לעשות. שני האזורים מושווים בפירוט בעמוד על stack מול heap.

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 ints, whatever int is here */
long *b = malloc(n * sizeof *b);     /* same line shape, right size */

/* the fragile form */
long *c = malloc(n * sizeof(int));   /* compiles, allocates too little */

השורה האחרונה היא באג אמיתי שאף קומפיילר לא מזהיר עליו: 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;
    }

    /* reading before writing is undefined behavior - so write first */
    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) היא התנהגות לא מוגדרת.
• שחררו כל בלוק בדיוק פעם אחת. פעמיים זה double free, שמשחית את הרישום הפנימי של המקצה.
• אחרי השחרור, המצביע כבר לא תקף. שימוש בו הוא use-after-free.

int *p = malloc(sizeof *p);
free(p);
*p = 5;        /* use-after-free - undefined behavior */
free(p);       /* double free - undefined behavior */

אף אחת מהשורות לא חייבת לקרוס מיד, וזה מה שהופך אותן למסוכנות: התוכנית עשויה לרוץ דקות ואז להיכשל במקום שלא קשור בכלל. ההגנה הזולה היא לאפס את המצביע:

free(p);
p = NULL;

free(NULL) מוגדרת במפורש כפעולה שלא עושה כלום, כך ש-free(p) שנייה אחרי זה לא מזיקה, ו-*p הופך לקריסה מיידית בנקודת התקלה האמיתית, במקום השחתה שקטה.

מערך דינמי מההתחלה ועד הסוף

זו הצורה של הקצאה אמיתית: קוראים מספר בזמן ריצה, קובעים לפיו את גודל הבלוק, משתמשים בו ומשחררים אותו.

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

int main(void) {
    int n = 8;   /* imagine this came from input or a file */

    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 מונעת את זה.

הקצאה בתוך פונקציה

כלל אורך החיים של ה-heap הוא מה שהופך את זה לחוקי, ומה שהופך החזרה של מערך מקומי ללא חוקית:

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

/* caller owns the returned block and must free it */
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 משאיר מקום לתו ה-null המסיים, אותו כלל גודל כמו בכל מקום במחרוזות. ושימו לב להערה מעל הפונקציה: כשפונקציה מחזירה זיכרון מוקצה, מי שמשחרר אותו הוא חלק מהחוזה שלה. לכתוב את זה אינו בירוקרטיה; זה הדבר היחיד שמונע דליפה.

structs ב-heap

אותו ניב עובד לכל טיפוס:

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

    /* an array of them */
    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.
• כל מסלול שגיאה אחרי הקצאה חייב לשחרר את מה שהוא כבר מחזיק.