Stack מול Heap ב-C: אורך חיים, מצביעים תלויים ומתי להשתמש בכל אחד

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

שלושת האזורים

  כתובות גבוהות
  +---------------------------+
  |  stack                    |  משתנים מקומיים, פרמטרים, כתובות חזרה
  |    grows downward  |      |  משתחררים אוטומטית ביציאה
  |                    v      |
  +---------------------------+
  |         (unused gap)      |
  +---------------------------+
  |                    ^      |
  |    grows upward    |      |
  |  heap                     |  בלוקים של malloc / calloc / realloc
  +---------------------------+  משתחררים רק עם free()
  |  static / global data     |  גלובליים ו-static, כל הריצה
  +---------------------------+
  |  code (text)              |  קוד המכונה, לקריאה בלבד
  +---------------------------+
  כתובות נמוכות

• אחסון אוטומטי (ה-stack) מחזיק פרמטרים של פונקציות ומשתנים מקומיים שאינם static. קטע של stack נתפס כשנכנסים לפונקציה ומשתחרר כשהיא חוזרת. הגודל נקבע בזמן קומפילציה.
• אחסון דינמי (ה-heap) מחזיק את כל מה שמגיע מ-malloc, calloc ו-realloc. הגודל נקבע בזמן ריצה, ואורך החיים מסתיים רק ב-free.
• אחסון סטטי מחזיק משתנים גלובליים וכל דבר שהוצהר static. הוא קיים לאורך כל ריצת התוכנית ומאותחל לאפס לפני ש-main מתחילה.

הכתובות בתרשים הן הסידור הנפוץ, לא הבטחה: התקן מתאר אורכי חיים, לא פריסה.

אחסון אוטומטי בפעולה

#include <stdio.h>

void demo(void) {
    int local = 42;             /* נוצרים כאן */
    int table[4] = {1, 2, 3, 4};

    printf("local = %d, table[0] = %d\n", local, table[0]);
}                               /* שניהם משתחררים כאן */

int main(void) {
    demo();
    demo();
    return 0;
}

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

המלכודת היא הסוגר המסולסל הסוגר. ברגע שהוא רץ, הזיכרון הזה נעלם.

המצביע התלוי

הנה הבאג שכל מתכנת C כותב פעם אחת:

/* שבור: מחזיר כתובת של זיכרון שכבר לא קיים */
int *make_counter(void) {
    int count = 0;
    return &count;          /* count מת בסוגר הזה */
}

int main(void) {
    int *p = make_counter();
    *p = 5;                 /* כתיבה לתוך stack frame מת */
    return 0;
}

&count הייתה כתובת תקינה לגמרי בזמן ש-make_counter רצה. ביציאה, שטח ה-stack הזה נמסר לכל פונקציה שנקראת אחריה, כך ש-p מצביע עכשיו לתוך המשתנים המקומיים של מישהו אחר. קריאה נותנת זבל, וכתיבה משחיתה אותם. GCC ו-Clang מזהירים בדיוק על הצורה הזו (-Wreturn-local-addr), לכן קמפלו עם אזהרות מופעלות.

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

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

/* נכון: הקורא מספק את האחסון, ולכן הוא חי יותר מהקריאה. */
void make_greeting(char *out, size_t size, const char *name) {
    snprintf(out, size, "Hello, %s!", name);
}

int main(void) {
    char message[64];
    make_greeting(message, sizeof message, "Ada");
    printf("%s\n", message);
    return 0;
}

הגרסה השבורה של הפונקציה הזו הייתה בונה את הטקסט ב-char buf[64] מקומי ועושה return buf;, כלומר מחזירה את הכתובת של buffer שמפסיק להתקיים באותו רגע בדיוק.

שלוש דרכים לתקן

1. הקורא מספק את ה-buffer (כמו שלמעלה). בלי הקצאה, בלי שאלת בעלות, וזה הסגנון הנפוץ ביותר בספריות C. הפונקציה מקבלת את הגודל כדי שתוכל להישאר בתוכו.

2. החזירו זיכרון מה-heap, ואמרו מי משחרר אותו.

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

/* מחזירה מחרוזת שהוקצתה עכשיו, והקורא חייב לשחרר אותה. */
char *make_greeting(const char *name) {
    size_t size = strlen(name) + 16;
    char *out = malloc(size);
    if (out == NULL) {
        return NULL;
    }
    snprintf(out, size, "Hello, %s!", name);
    return out;
}

int main(void) {
    char *message = make_greeting("Ada");
    if (message == NULL) {
        return 1;
    }
    printf("%s\n", message);
    free(message);
    return 0;
}

בלוק ה-heap חי יותר מהפונקציה בכוונה, וזה כל הרעיון של זיכרון דינמי. המחיר הוא הערת הבעלות וה-free של הקורא.

3. השתמשו באחסון סטטי, כש-buffer משותף יחיד הוא מקובל:

#include <stdio.h>

int *next_id(void) {
    static int id = 0;      /* מופע אחד, שחי לאורך כל התוכנית */
    id++;
    return &id;             /* בטוח: אחסון סטטי אף פעם לא נעלם */
}

int main(void) {
    printf("%d\n", *next_id());
    printf("%d\n", *next_id());
    printf("%d\n", *next_id());
    return 0;
}

static בתוך פונקציה שומר על הscope של המשתנה מקומי ונותן לו את אורך החיים של התוכנית, ולכן החזרת הכתובת שלו חוקית. המחיר הוא שתמיד יש רק אחד כזה: כל הקוראים חולקים אותו, וזה הופך את הדפוס ללא שמיש בקוד עם threads, ומפתיע אפילו בקוד עם thread אחד כששני קוראים מחזיקים את המצביע באותו זמן.

גודל: איפה ה-stack נגמר

שטח ה-stack קטן וקבוע. ה-thread הראשי מקבל בדרך כלל 1 MB ב-Windows ו-8 MB ב-Linux, ו-thread שנוצר מקבל לעיתים קרובות הרבה פחות. ה-heap מוגבל בזיכרון הפנוי של המערכת.

void bad(void) {
    int huge[1000000];      /* כ-4 MB של stack: כנראה יקרוס בכניסה */
    huge[0] = 1;
}

אין הודעת אבחון ואין NULL לבדוק: התוכנית פשוט מתה, בדרך כלל עם segmentation fault, עוד לפני שהשורה הראשונה בגוף רצה. גרסת ה-heap מדווחת על כישלון כמו שצריך:

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

int main(void) {
    size_t n = 1000000;

    int *huge = malloc(n * sizeof *huge);
    if (huge == NULL) {
        fprintf(stderr, "could not allocate %zu ints\n", n);
        return 1;
    }

    huge[0] = 1;
    huge[n - 1] = 2;
    printf("%d ... %d (%zu bytes)\n", huge[0], huge[n - 1], n * sizeof *huge);

    free(huge);
    return 0;
}

רקורסיה עמוקה ממצה את ה-stack באותה דרך, frame אחר frame: פונקציה רקורסיבית שיצאה משליטה היא הגורם הנפוץ ביותר ל-stack overflow בפועל.

עלות ולוקליות

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

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

לראות את האזורים

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

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

int global_value = 1;

int main(void) {
    static int static_value = 2;
    int local_value = 3;

    int *heap_value = malloc(sizeof *heap_value);
    if (heap_value == NULL) {
        return 1;
    }
    *heap_value = 4;

    printf("global: %p\n", (void *)&global_value);
    printf("static: %p\n", (void *)&static_value);
    printf("heap:   %p\n", (void *)heap_value);
    printf("local:  %p\n", (void *)&local_value);

    free(heap_value);
    return 0;
}

המשתנה הגלובלי והסטטי יושבים זה ליד זה, בלוק ה-heap נמצא במקום אחר, והמשתנה המקומי בדרך כלל רחוק משניהם. בצעו cast ל-void * עבור %p, כי זה מה שה-format specifier דורש.

איך לבחור

השתמשו ב-stack כש:

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

השתמשו ב-heap כש:

• הגודל תלוי בקלט, בקובץ או בחישוב,
• הנתונים צריכים לחיות יותר מהפונקציה שיצרה אותם,
• או שהם גדולים מספיק כדי לאיים על מגבלת ה-stack.

השתמשו ב-static כש:

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

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

שני באגים שהם תמונת ראי

כדאי לתת להם שם יחד, כי זו אותה שאלה של אורך חיים שנענתה בשתי דרכים:

• מצביע תלוי: הזיכרון מת לפני שהמצביע מת. החזרת &local, או שימוש במצביע אחרי free. התוכנית קוראת או כותבת לאחסון ששייך עכשיו למשהו אחר.
• דליפת זיכרון: המצביע מת לפני שהזיכרון מת. איבוד ההפניה האחרונה לבלוק של malloc. שום דבר לא נשבר מיד, התהליך פשוט גדל.

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