מצביעי NULL ב-C: מה NULL אומר ואיך בודקים אותו

מצביע תמיד מחזיק ערך כלשהו. כשעוד אין לו אובייקט להצביע עליו, לפני שמשימים לו, אחרי שמה שהוא הצביע עליו שוחרר, או כשלפונקציה אין מה להחזיר, הוא צריך ערך שאומר באופן חד משמעי "אין כאן כלום". הערך הזה הוא מצביע ה-null, ו-NULL הוא השם שכותבים.

המשמעת סביבו קטנה ומשתלמת כל הזמן: הציבו NULL במצביעים כשאין להם יעד, בדקו NULL לפני dereference, והחזירו NULL כשאין לכם תוצאה.

מה NULL באמת

NULL הוא מאקרו, שמוגדר ב-<stddef.h> ונמשך גם על ידי <stdio.h>, <stdlib.h>, <string.h> ואחרים. הוא מתרחב לקבוע מצביע null, בדרך כלל ((void*)0) או 0 פשוט.

תקן C מבטיח את התכונה שחשובה: מצביע null לא שווה למצביע לאף אובייקט או פונקציה אמיתיים. שני מצביעי null מאותו טיפוס תמיד שווים זה לזה.

#include <stdio.h>

int main(void) {
    int value = 42;
    int *good = &value;
    int *none = NULL;

    printf("good = %p\n", (void *)good);
    printf("none = %p\n", (void *)none);

    printf("\ngood == NULL? %s\n", good == NULL ? "yes" : "no");
    printf("none == NULL? %s\n", none == NULL ? "yes" : "no");

    return 0;
}

רוב המערכות מדפיסות (nil) או 0x0 עבור מצביע ה-null, כלומר הכתובת אפס. זה מימוש נפוץ, לא כלל; התקן אף פעם לא מבטיח שהביטים הם אפס. מה שהוא מבטיח הוא ההשוואה, אז כתבו p == NULL, ולעולם לא משהו שתלוי בייצוג.

dereference ל-NULL קורס

הסיבה לכל בדיקת null שקיימת:

int *p = NULL;
printf("%d\n", *p);   // התנהגות לא מוגדרת: כמעט בטוח קריסה

ב-Windows, ב-macOS וב-Linux, הדף הראשון של מרחב הכתובות נשאר בכוונה לא ממופה, כך שהמעבד לוכד את הגישה ומערכת ההפעלה הורגת את התוכנית. תראו:

Segmentation fault (core dumped)          # Linux
zsh: segmentation fault  ./program        # macOS

הקריסה המיידית הזו היא יתרון. היא הופכת באג לוגי לכישלון רועש בדיוק בשורה שגרמה לו, במקום השחתה שקטה שתמצאו שלושה שבועות אחר כך. ראו את העמוד על segmentation fault כדי ללמוד לקרוא את הקריסה ולמצוא את השורה.

זו הסיבה ש"null pointer" הוא לא exception שתופסים ב-C. אין מנגנון להתאושש; יש רק בדיקה מראש.

בדקו את מה שעלול להיכשל

פונקציות שעלולות להיכשל מסמנות את זה בהחזרת NULL. הבדיקה היא לא נימוס אופציונלי: החלופה היא קריסה.

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

int main(void) {
    // 1. malloc מחזירה NULL כשההקצאה נכשלת
    int *numbers = malloc(5 * sizeof *numbers);
    if (numbers == NULL) {
        fprintf(stderr, "out of memory\n");
        return 1;
    }
    for (int i = 0; i < 5; i++) {
        numbers[i] = i * i;
    }
    printf("allocated ok: %d %d %d %d %d\n",
           numbers[0], numbers[1], numbers[2], numbers[3], numbers[4]);
    free(numbers);

    // 2. strchr מחזירה NULL כשהתו לא נמצא
    const char *text = "hello world";
    const char *found = strchr(text, 'w');
    if (found != NULL) {
        printf("found 'w' at index %td\n", found - text);
    }

    const char *missing = strchr(text, 'z');
    printf("'z' found? %s\n", missing != NULL ? "yes" : "no");

    return 0;
}

הספרייה הסטנדרטית מלאה בהן: malloc, calloc, realloc, fopen, strchr, strstr, getenv, bsearch. כל אחת מהן עונה על "אין תוצאה" עם NULL. ראו את העמוד על זיכרון דינמי לסיפור המלא של ההקצאה.

שתי צורות לבדיקה, שתיהן נפוצות:

if (p == NULL) { /* טיפול */ }   // מפורש: עדיף בשביל הבהירות
if (!p)        { /* טיפול */ }   // תמציתי: מסתמך על כך ש-NULL נחשב שקר

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

NULL מול 0 מול לא מאותחל

שלושה מצבים שונים שמתחילים מטשטשים ביניהם:

int *a = NULL;     "points at nothing" - testable, safe to check
int *b;            uninitialized - holds garbage, NOT testable
int *c = &x;       points at a real object

המסוכן הוא b. הבתים שלו הם מה שנשאר במקום הזה במחסנית, שעשוי להיות אפס (ולהיראות בסדר) או כתובת שנראית סבירה מקריאה קודמת. שום בדיקה לא יכולה להבדיל בינו לבין מצביע תקין, וההתנהגות משתנה בין build של debug ל-build של release.

#include <stdio.h>

int main(void) {
    int *safe = NULL;      // בוודאות כלום

    if (safe == NULL) {
        printf("safe is null - we can test for this\n");
    }

    // אי אפשר לבדוק מצביע לא מאותחל; הפתרון הוא לא ליצור כזה
    int *fixed = NULL;
    int value = 7;

    if (fixed == NULL) {
        printf("fixed starts null\n");
        fixed = &value;
    }
    printf("fixed now points at %d\n", *fixed);

    return 0;
}

אתחלו כל מצביע. אם אין לכם עדיין כתובת, NULL היא הכתובת. קמפלו עם -Wall -Wextra והקומפיילר יסמן בשבילכם הרבה שימושים לא מאותחלים.

לגבי 0: בהקשר של מצביע, הקבוע השלם 0 הוא קבוע מצביע ה-null, כך ש-p = 0; הוא C תקין. העדיפו בכל זאת את NULL. הוא מבטא כוונה, וזה חשוב בקריאות variadic שבהן הקומפיילר לא יכול להמיר בשבילכם:

execl("/bin/ls", "ls", 0);       // מסוכן: עלול להעביר int במקום שבו מצופה מצביע
execl("/bin/ls", "ls", (char *)NULL);   // נכון

C23 מוסיפה את nullptr, מילת מפתח עם טיפוס משלה שמונעת את כל סוג העמימות הזה; NULL נשאר נכון ונייד בכל מקום.

דפוסים הגנתיים

שמרו על הכניסה של פונקציה שמקבלת מצביעים.

#include <stdio.h>

// מחזירה 0 בהצלחה, ערך שונה מאפס על קלט גרוע
int average(const int *arr, int n, double *out) {
    if (arr == NULL || out == NULL || n <= 0) {
        return 1;                    // מסרבים במקום לקרוס
    }
    long total = 0;
    for (int i = 0; i < n; i++) {
        total += arr[i];
    }
    *out = (double)total / n;
    return 0;
}

int main(void) {
    int data[4] = {10, 20, 30, 41};
    double result;

    if (average(data, 4, &result) == 0) {
        printf("average = %.2f\n", result);
    }

    if (average(NULL, 4, &result) != 0) {
        printf("rejected a NULL array instead of crashing\n");
    }

    return 0;
}

הציבו NULL אחרי שחרור. free לא משנה את המצביע שלכם: הוא רק משחרר את הזיכרון. המצביע הישן שנשאר הוא מצביע תלוי (dangling), והשימוש בו הוא התנהגות לא מוגדרת שלעתים קרובות לא קורסת מיד.

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

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

    *p = 99;
    printf("value = %d\n", *p);

    free(p);
    p = NULL;          // עכשיו הטעות היא קריסה רועשת, לא שקטה

    if (p == NULL) {
        printf("p is null - safe to test, safe to free again\n");
    }

    free(p);           // free(NULL) מוגדר במפורש כפעולה ריקה, תמיד בטוח
    return 0;
}

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

החזירו NULL כדי לומר "אין תוצאה", וכתבו את זה.

// מחזירה מצביע לאיבר המתאים, או NULL אם אין כזה
int *find(int *arr, int n, int target);

תעדו את זה בהערה מעל הפונקציה. קוראת שיודעת ש-NULL אפשרי כותבת את הבדיקה; קוראת שלא יודעת, לא תכתוב.

רשימת בדיקה מהירה

• אתחלו כל מצביע, עם כתובת אמיתית או עם NULL.
• בדקו את הערך המוחזר של malloc, calloc, realloc ו-fopen לפני שמשתמשים בו.
• בדקו פרמטרים מסוג מצביע בראש כל פונקציה שעלולים לקרוא לה עם קלט גרוע.
• הציבו NULL במצביעים מיד אחרי free.
• כתבו NULL, לא 0, בכל פעם שהכוונה למצביע.
• בנו עם -Wall -Wextra, וכשאפשר, הריצו תחת sanitizer: gcc -fsanitize=address,undefined תופס dereference ל-null עם דוח מדויק.