דלגו לתוכן הראשי
גאמא קוד

שפת C - תיאוריה

Memory Management in C

ניהול זיכרון ב-C: malloc ו-free, Heap, Dangling Pointer, union וגדלי מבנים.

בחרו את הרמה שמתאימה לכם ואת הסט שתרצו לתרגל

חומר לימוד

Memory Management in C: מפת הזיכרון, מחסנית, Heap, באגים, פריסת struct ומחרוזות

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

  • מפת הזיכרון של תהליך: ההפרדה בין text, rodata, data, bss, ה-Heap וה-Stack, ואיך קובעים לאן שייך כל משתנה.
  • המחסנית (Stack): איך פועלות מסגרות מחסנית, למה ההקצאה בהן מהירה, מתי מתרחש Stack Overflow, ומהן הסכנות של החזרת כתובת מקומית, VLA, alloca ו-Stack Smashing.
  • ה-Heap ומשפחת malloc: הקצאה דינמית עם malloc, calloc, realloc ושחרור עם free, כולל טיפול בכישלון ובחירה בין המחסנית ל-Heap.
  • באגים בזיכרון וכלים לאיתורם: דליפות זיכרון, מצביעים תלויים ופרועים, Use After Free, שחרור כפול, חריגה מגבולות, בעלות על מצביעים, valgrind, AddressSanitizer, פיצול זיכרון ו-Pool Allocator.
  • מבנים ומחרוזות בזיכרון: יישור (Alignment), ריפוד (Padding), union, Flexible Array Member, העתקה רדודה מול עמוקה, וההבדל בין sizeof ל-strlen.

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

מה צריך לדעת מראש: משתנים, פונקציות, מערכים והיכרות ראשונית עם מצביעים (לקיחת כתובת עם &, הפנייה עם * והערך NULL). כל הגדלים כאן הם של gcc על x86-64 תחת Linux: char הוא בית אחד, short שני בתים, int ארבעה, ו-long, double ומצביע שמונה בתים כל אחד. את הדוגמאות הרצנו בפועל עם gcc 16 (MinGW) על Windows, ברוב המקרים עם -O0. לכן ליד כל פלט שתלוי במערכת, בקומפיילר או באופטימיזציה כתוב איך הוא נוצר ומה שונה ב-Linux.

מפת הזיכרון של תהליך

האזורים בזיכרון התהליך

למה משתנה static שורד את סוף הפונקציה ומשתנה רגיל לא? התשובה מתחילה בכך שמערכת ההפעלה אינה נותנת לתהליך גוש זיכרון אחיד, אלא בונה לו מרחב כתובות וירטואלי פרטי ומחלקת אותו לאזורים. לכל אזור יש ייעוד, הרשאות (קריאה, כתיבה, הרצה) ומשך חיים.

Text
high addresses (top of the picture)
  stack    call frames; grows toward LOW addresses, downward here   read + write
           ... unused virtual space ...
  heap     malloc blocks; grows toward HIGH addresses, upward here  read + write
  bss      globals/statics with no start value, or zero (zeroed)    read + write
  data     globals/statics with a non-zero start value              read + write
  rodata   "string literals", const tables                          read only
  text     machine code of every function                           read + execute
low addresses (bottom of the picture)
מקטעמה יושב בואיך הוא מנוהלכמה זמן
textקוד המכונה של כל הפונקציותנטען מקובץ ההרצה; קריאה והרצה, בלי כתיבהעד סוף התהליך
rodataליטרלים כמו "ready" וקבועים שנקבעו מראשנטען מקובץ ההרצה; קריאה בלבד, וכתיבה לליטרל היא התנהגות לא מוגדרתעד סוף התהליך
dataגלובליים ו-static עם ערך התחלתי שאינו אפסנטען מקובץ ההרצה; קריאה וכתיבהעד סוף התהליך
bssגלובליים ו-static בלי ערך התחלתי, או שערכם אפסהמערכת מאפסת אותם לפני main; קריאה וכתיבהעד סוף התהליך
heapבלוקים שהתוכנית ביקשה תוך כדי ריצהידני: malloc, calloc ו-realloc מקצות, free מחזירהמההקצאה עד ה-free
stackמקומיים, פרמטרים וכתובות חזרהאוטומטי: מסגרת נפתחת בכניסה לפונקציה ונסגרת ביציאהעד שהפונקציה חוזרת

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

C
/* sz3.c */
#include <stdio.h>

int seeded[1000] = {1};   /* 4000 bytes, has a start value */
int blank[1000];          /* 4000 bytes, no start value    */

int main(void) {
    int scratch[1000] = {0};   /* 4000 bytes, created per call */
    printf("%d %d %d\n", seeded[0], blank[0], scratch[0]);
    return 0;
}
פלט
$ gcc -O0 -c sz3.c && size sz3.o
   text	   data	    bss	    dec	    hex	filename
    232	   4000	   4000	   8232	   2028	sz3.o

seeded נספר ב-data ו-blank ב-bss, ואילו scratch אינו מופיע באף עמודה: הוא יתקיים רק בזמן הריצה, על המחסנית. כשמוסיפים בתוך main גם static char cache[500] עמודת bss גדלה ל-4512 (500 בתים ועוד ריפוד של יישור) ועמודת data נשארת 4000.

המספרים הם של אובייקט COFF שנבנה ב-Windows עם gcc -O0 -c. באובייקט ELF של Linux עמודת text וריפוד היישור ב-bss יכולים להיות שונים, אבל data של 4000 והחלוקה בין data ל-bss נשארות כפי שהן.

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

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

חזרה לתוכן העניינים

איפה יושב כל משתנה

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

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

double rate = 0.25;      /* data: global with a non-zero start value */
long total;              /* bss: global with no initializer */

char *clone_name(const char *src) {
    static int clones = 100;               /* data: one copy for the whole run */
    char *dup = malloc(strlen(src) + 1);   /* dup: stack; its block: heap */
    if (dup != NULL)
        strcpy(dup, src);
    clones++;
    total += clones;
    return dup;
}

void greet(void) {
    int n = 3;                    /* stack: ordinary local */
    const char *msg = "hello";    /* msg: stack; the literal: rodata */
    char *c = clone_name(msg);
    total += n;
    free(c);
}
פלט
$ gcc -Wall -O0 -c place.c && nm place.o | grep -E "rate|total|clones"
0000000000000008 d clones.0
0000000000000000 D rate
0000000000000000 B total

הכלי nm מסמן כל סמל באות של המקטע שלו: D ו-d ל-data, B ל-bss. לכן rate ו-clones.0 (כך נקרא ה-static המקומי) יושבים ב-data, ו-total ב-bss. את n, dup ו-msg לא תמצאו שם, כי הם נולדים רק בזמן הריצה, במסגרות של המחסנית.

כדי לא לטעות, שאלו שלוש שאלות על כל שם בקוד, לפי הסדר:

  1. האם הוא מוגדר מחוץ לפונקציה, או בתוכה עם static? אם כן הוא באזור הסטטי: data כשיש לו ערך התחלתי שאינו אפס, אחרת bss.
  2. אם לא, הוא מקומי רגיל ויושב במסגרת המחסנית של הפונקציה.
  3. האם הערך שלו הוא כתובת שהגיעה מ-malloc? הבלוק עצמו ב-Heap, אבל המצביע שמחזיק אותו הוא משתנה נפרד, שחוזר לשאלה 1 או 2.
שםאזורהסבר
ratedataגלובלי עם ערך התחלתי שאינו אפס (0.25)
totalbssגלובלי בלי אתחול: המערכת מאפסת אותו לפני main
clonesdatastatic מקומי: הוא נוצר ומאותחל פעם אחת, עוד לפני הריצה, ולכן כל קריאה חדשה פוגשת את הערך שנשאר. הוא אינו בלוק של malloc, ולכן free עליו היא התנהגות לא מוגדרת
nstackמקומי רגיל: נעלם כשהמסגרת נסגרת
dupstackהמצביע בלבד (8 בתים ב-x86-64); הבלוק שהוא מחזיק יושב ב-Heap
msgstackהמצביע במחסנית, והמחרוזת "hello" ב-rodata
תרחיש 1: המונה ששורד והמונה שנולד מחדש

הפונקציה next_order נקראת שלוש פעמים ברצף. next_id יושב ב-data, ואילו attempt נבנה מחדש במחסנית בכל כניסה.

C
#include <stdio.h>

void next_order(void) {
    static int next_id = 500;
    int attempt = 0;
    next_id++;
    attempt++;
    printf("id=%d attempt=%d\n", next_id, attempt);
}

int main(void) {
    next_order();
    next_order();
    next_order();
    return 0;
}
פלט
id=501 attempt=1
id=502 attempt=1
id=503 attempt=1

בקריאה הראשונה next_id עולה מ-500 ל-501, והערך הזה נשאר במקומו גם אחרי שהפונקציה חזרה. ל-attempt אין מה לשמר: המסגרת נסגרה, והקריאה הבאה מקבלת משתנה חדש שמתחיל ב-0. לכן העמודה הראשונה בפלט צוברת והשנייה תקועה על 1.

טעויות נפוצות
  • משתנה static שהוגדר בתוך פונקציה נמחק ברגע שהפונקציה חוזרת, בדיוק כמו שאר המקומיים. מקומו ב-data או ב-bss, מחוץ למסגרת. הוא חי כל עוד התהליך חי.
  • אם p = malloc(...), אז גם p יושב ב-Heap. ב-Heap יושב רק הבלוק. p הוא מקומי רגיל, שמחזיק את הכתובת של הבלוק, ולכן הוא במחסנית.
  • גלובליים ו-static נשמרים במחסנית כל עוד התוכנית רצה. הם יושבים באזור סטטי משלהם, data או bss. המחסנית מכילה אך ורק מסגרות של קריאות שעדיין פעילות.
  • קוד המכונה של הפונקציות נטען למחסנית. ההוראות יושבות ב-text, אזור שמיועד לקריאה והרצה בלבד ואין לו קשר למחסנית או ל-Heap.
בדקו את עצמכם
בפונקציה מופיעות ארבע שורות: char label[32];, static int calls = 7;, int *tbl = malloc(8 * sizeof *tbl); ו-tbl[0] = calls;. ציינו באיזה אזור יושב כל אחד מהביטויים label, calls, tbl ו-tbl[0].

label במחסנית (כל 32 הבתים), calls ב-data (הוא static עם ערך התחלתי שאינו אפס), tbl במחסנית (המצביע בלבד), ו-tbl[0] ב-Heap, כי הוא חלק מהבלוק שהחזירה malloc.

חזרה לתוכן העניינים

משתנה גלובלי מול הקצאה דינמית

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

היבטמשתנה גלובליבלוק ב-Heap
מי קובע את הגודלהקומפיילר, לפני הריצההתוכנית, בזמן ריצה (למשל לפי קלט)
כמה זמן הוא תופס מקוםמתחילת התהליך ועד סופו, גם כשאיש לא נוגע בומה-malloc ועד ה-free
אפשר לשנות גודל?לאכן, עם realloc
שחרוראין; קריאה ל-free עליו היא התנהגות לא מוגדרת (התקן אינו מבטיח מה יקרה)חובה לקרוא ל-free פעם אחת
אתחולפעם אחת לפני main; כניסה לפונקציה לא מחזירה אותו לערך ההתחלתיבידי התוכנית: malloc משאירה זבל, calloc מאפסת

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

טעויות נפוצות
  • גלובלי שאף פונקציה לא קוראת ממנו מפונה מהזיכרון. הוא תופס את מקומו עד שהתהליך מסתיים, בלי קשר לשימוש בו.
  • כל כניסה לפונקציה שמשתמשת בגלובלי מחזירה אותו לערך ההתחלתי. האתחול קורה פעם אחת, לפני main. ערך שנכתב בקריאה אחת ממשיך לחכות לקריאה הבאה.
  • מערך גלובלי הוא בלוק של Heap, ולכן בסוף התוכנית צריך להפעיל עליו free. הוא יושב ב-data או ב-bss, ו-free על כתובת כזאת היא התנהגות לא מוגדרת.
בדקו את עצמכם
שירות רשת מנהל רשומות לקוחות, ומספרם בין ריצה לריצה נע בין עשרות לעשרות אלפים. מה הבעיה במערך גלובלי של 50,000 תאים, ומה הפתרון?

בימים שקטים רוב המערך מבוזבז ואי אפשר להחזיר אותו, ובימים עמוסים, אם יגיעו יותר מ-50,000 לקוחות, אי אפשר להגדיל אותו. הפתרון הוא להקצות ב-Heap בגודל שהקלט דורש, להגדיל עם realloc לפי הצורך ולשחרר ב-free.

חזרה לתוכן העניינים

המחסנית (Stack)

מסגרת מחסנית ולמה המחסנית מהירה

כשפונקציה קוראת לפונקציה אחרת, המעבד חייב לזכור לאן לחזור, והפונקציה הנקראת צריכה מקום למשתנים שלה. את שני הצרכים האלה פותרת המחסנית (Call Stack): אזור פרטי שכל thread מקבל לעצמו, שבו הקריאה האחרונה שנפתחה היא הראשונה להסתיים (LIFO).

לכל קריאה שנפתחת נבנית בראש המחסנית יחידה משלה: מסגרת (Stack Frame, ובאנגלית נוספת Activation Record). בסיום הקריאה היחידה מתפרקת, והריצה חוזרת אל הקורא, בכתובת שהמסגרת שמרה.

שאלה טובה: אם הארגומנטים עוברים באוגרים, למה למסגרת צריך להיות מקום בשבילם? ב-x86-64 Linux ששת הארגומנטים השלמים הראשונים אכן מגיעים באוגרים (רגיסטרים), אבל בבנייה בלי אופטימיזציות הקומפיילר מעתיק כל אחד מהם לחריץ במסגרת, ושם הוא נשאר זמין גם אחרי קריאה לפונקציה אחרת.

מה נמצא בתוך מסגרת אחת, ברמת ההוראות:

  • כתובת החזרה: המקום שבו הריצה תמשיך אחרי ה-ret.
  • המשתנים המקומיים של הפונקציה, ובבנייה בלי אופטימיזציות גם העתקים של הפרמטרים שהגיעו באוגרים.
  • אוגרים שהפונקציה חייבת להחזיר לקורא כפי שהיו (callee-saved), ומצביע המסגרת של הקורא כשהקומפיילר משתמש בו.
  • ארגומנטים שלא נכנסו באוגרים, כשיש יותר משישה שלמים.

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

ראש המחסנית הנוכחי נמצא תמיד באוגר RSP. את בסיס המסגרת מסמן לעיתים RBP, אבל gcc ב-x86-64 מוותר עליו מרמת -O1 ומעלה. בתרשים הבא החץ מצביע על ראש המחסנית.

Text
log_line calls format_time, and format_time calls pad2:

 high addresses
 +-------------------------------------------+
 | log_line     locals, return -> main       |
 +-------------------------------------------+
 | format_time  locals, return -> log_line   |
 +-------------------------------------------+
 | pad2         locals, return -> format_time|
 +-------------------------------------------+  <- RSP, the current top
 low addresses

 pad2 returns: its frame is dropped, RSP climbs back to the top
 of format_time's frame, and format_time runs on from the saved address

כדי למסור 48 בתים malloc מחפשת בלוק פנוי שמתאים, מעדכנת את רישומי המקצה, וכל זה בתוך קריאה לפונקציית ספרייה (לרוב בלי פנייה לליבה, כי המקצה כבר מחזיק זיכרון שקיבל מראש). במחסנית אותם 48 בתים עולים חיסור בודד, sub rsp, 48, בכניסה, וחיבור חזרה ביציאה. הנתונים עצמם יושבים ב-RAM רגיל, והאוגר שמבצע את ההקצאה הוא RSP.

תרחיש 2: ספירת ספרות ברקורסיה

הפונקציה digits מחזירה כמה ספרות יש במספר. בנוסף היא מדפיסה את המרחק בבתים בין המשתנה המקומי marker של הקריאה הנוכחית לזה של הקריאה שקדמה לה, כדי שנראה את המסגרות נערמות. הדוגמה קומפלה ללא אופטימיזציה, עם gcc -O0.

C
#include <stdio.h>
#include <stdint.h>

static uintptr_t last;   /* address of the previous call's marker */

int digits(int n) {
    char marker;
    uintptr_t here = (uintptr_t)&marker;
    if (last != 0)
        printf("frame distance: %ld bytes\n", (long)(last - here));
    last = here;
    if (n < 10)
        return 1;
    return 1 + digits(n / 10);
}

int main(void) {
    printf("digits(8305) = %d\n", digits(8305));
    return 0;
}
פלט
frame distance: 64 bytes
frame distance: 64 bytes
frame distance: 64 bytes
digits(8305) = 4
  1. digits(8305) פותחת מסגרת ראשונה, וקוראת ל-digits(830).
  2. digits(830) פותחת מסגרת שנייה ומתחתיה, וקוראת ל-digits(83).
  3. digits(83) פותחת מסגרת שלישית וקוראת ל-digits(8).
  4. digits(8) פותחת מסגרת רביעית, ומחזירה 1 כי 8 קטן מ-10. המסגרת נסגרת.
  5. digits(83) מחזירה 1 + 1, כלומר 2, ו-digits(830) מחזירה 3. לבסוף digits(8305) מחזירה 4 ל-main.

בשיא הרקורסיה ארבע קריאות חיות יחד, וכל אחת מחזיקה n ו-marker משלה. אף מסגרת לא דורסת את קודמתה: digits(830) עדיין ממתינה לתוצאה של digits(83) כדי לחשב 1 + ..., ואילו נדרסה, לא היה לה לאן לחזור ומה לחבר. שלוש שורות ההדפסה הן שלושת המעברים בין ארבע מסגרות סמוכות, וכל מעבר ירד 64 בתים בבנייה הזאת (gcc -O0 על Windows).

המספר תלוי בקומפיילר ובמערכת, והניסוי מאבד את משמעותו עם אופטימיזציה: ב--O2 הקומפיילר ב-gcc 16 (MinGW) מטמיע ומפרש כמה רמות של digits בתוך מסגרת אחת, ובפועל הודפס frame distance: 67 bytes ואחריו -1 פעמיים. הקריאה ל-digits עדיין קיימת בקוד שנוצר, אבל הפער בין כתובות ה-marker כבר אינו מודד מסגרת אחת לכל רמה.

טעויות נפוצות
  • הבלוק ש-malloc מחזירה יושב במסגרת מחסנית. הבלוק ב-Heap וחי אחרי שהמסגרת הקצרה של malloc נסגרה. המסגרות מחזיקות מקומיים, פרמטרים וכתובות חזרה, לא בלוקים של Heap.
  • המחסנית מהירה כי המעבד מחזיק אותה באוגרים. המחסנית היא אזור רגיל ב-RAM. היא מהירה כי הקצאה ושחרור הם הזזה בודדת של RSP.
  • במעבדי x86 המחסנית נבנית מלמטה למעלה, לעבר כתובות גדולות. היא נבנית כלפי כתובות נמוכות יותר, וה-Heap הוא שגדל כלפי גבוהות.
  • המחסנית נועדה לבקשות שהגודל שלהן נקבע רק בזמן ריצה. גודל משתנה לפי צורך הוא עבודה של ה-Heap. מסגרת מתוכננת בקומפילציה.
בדקו את עצמכם
הפונקציה report קוראת חמש פעמים, בלולאה, ל-format_row, ומתוך format_row יש קריאה אחת ל-pad2. כמה מסגרות (לא כולל report ו-main) יכולות להיות פעילות במקביל?

שתיים לכל היותר: אחת של format_row ואחת של pad2 בתוכה. כל קריאה ל-format_row נסגרת לפני שהבאה אחריה מתחילה, כך שהחמש לא מצטברות.

חזרה לתוכן העניינים

משתנים מקומיים וכתובת שחוזרת מפונקציה

למשתנה מקומי רגיל יש משך חיים אוטומטי (Automatic Storage Duration): הוא נולד כשהריצה נכנסת לבלוק שבו הוגדר, ומת כשהיא יוצאת ממנו. משתנה שהוגדר בראש פונקציה מת אפוא ברגע שהפונקציה חוזרת. ומי שקורא int x; לפני שכתב אליו מקבל זבל שאין לסמוך עליו: זו התנהגות לא מוגדרת (Undefined Behavior), ולא אפס.

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

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

C
#include <stdio.h>

int *latest_reading(void) {
    int level = 87;
    return &level;
}

int main(void) {
    int *p = latest_reading();
    printf("%d\n", *p);
    return 0;
}
פלט
$ gcc -Wall -O0 -o latest latest.c
latest.c: In function 'latest_reading':
latest.c:5:12: warning: function returns address of local variable [-Wreturn-local-addr]
    5 |     return &level;
      |            ^~~~~~

הפלט למעלה הוא של הקומפילציה: gcc רק מזהיר, והבנייה מצליחה. בהרצה התוכנית קרסה, אבל מסיבה מפתיעה: אחרי האזהרה gcc עצמו מחליף את return &level ב-return 0, ולכן main קיבלה NULL אמיתי והגישה אליו קרסה (access violation ב-Windows, Segmentation Fault ב-Linux). זה מעשה של הקומפיילר ולא של השפה: התקן אינו מבטיח דבר, ומצביע תלוי רגיל לא מתאפס, כפי שהדוגמה הבאה מראה.

הדוגמה הבאה מראה אפשרות אחרת, שבה התוכנית ממשיכה לרוץ אבל מחזירה ערך שגוי. כאן הכתובת נשמרת במשתנה גלובלי במקום להיות מוחזרת, ו-gcc אינו מחליף אותה ב-NULL. עם -Wall הוא מזהיר (-Wdangling-pointer), בלי הדגל הוא שותק, והבנייה מצליחה בשני המקרים. הקוד קומפל עם gcc -O0:

C
#include <stdio.h>

int *kept;

void remember(void) {
    int level = 87;
    kept = &level;       /* the address outlives the variable */
}

int noisy(int a, int b) {
    int t[4] = {a, b, a + b, a * b};
    return t[2] + t[3];
}

int main(void) {
    remember();
    printf("before: %d\n", *kept);
    noisy(5, 6);
    printf("after:  %d\n", *kept);
    return 0;
}
פלט
before: 87
after:  30

המספרים כאן הם של gcc 16 (MinGW) על Windows x64 עם -O0. הקריאה ל-noisy בנתה את המסגרת שלה על אותו מקום שבו חי level, ולכן *kept מצביע עכשיו אל t[3], שערכו 5 * 6 = 30.

המספר 30 תלוי בפריסת המסגרת של הקומפיילר ושל המערכת הזאת, ובקומפיילר אחר, ב-Linux או ברמת אופטימיזציה אחרת הוא יכול להיות שונה. עם -O2 אותו קוד הדפיס בבדיקה שלנו שני מספרים שרירותיים ולא 87, וזה הטעם שבהתנהגות לא מוגדרת.

ניסיון לתקןלמה זה לא עוזר
להוסיף const למשתנהconst אוסר שינוי ערך, והוא לא נוגע לשאלה מתי המשתנה מפסיק להתקיים
להוסיף registerזה רמז לאופטימיזציה בלבד, ואינו מאריך חיים
להשתמש במצביע מיד, לפני כל קריאה אחרתגם אם הערך נראה תקין, הגישה נשארת התנהגות לא מוגדרת
להעביר את הכתובת ל-free או ל-reallocשתיהן מיועדות רק לבלוקים שהתקבלו מ-malloc, calloc או realloc; על כתובת במחסנית הן התנהגות לא מוגדרת

יש שתי דרכים נכונות להעביר מערך או נתון מורכב החוצה: להקצות אותו ב-Heap ולהחזיר מצביע (ולתעד שהקורא אחראי ל-free), או לבקש מהקורא חוצץ וגודל ולכתוב לתוכו. הדוגמה מכילה את שתיהן.

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

/* Heap version: whoever receives the pointer must call free() later. */
double *to_fahrenheit(const double *celsius, size_t n) {
    double *out = malloc(n * sizeof *out);
    if (out == NULL)
        return NULL;
    for (size_t i = 0; i < n; i++)
        out[i] = celsius[i] * 9.0 / 5.0 + 32.0;
    return out;
}

/* Caller-buffer version: the caller decides where the storage lives. */
size_t to_kelvin(const double *celsius, size_t n, double *out, size_t cap) {
    size_t used = n < cap ? n : cap;
    for (size_t i = 0; i < used; i++)
        out[i] = celsius[i] + 273.15;
    return used;
}

int main(void) {
    double c[] = {-5.0, 0.0, 21.5, 100.0};

    double *f = to_fahrenheit(c, 4);
    if (f != NULL) {
        int i = 0;
        while (i < 4)
            printf("%.1f ", f[i++]);
        printf("\n");
        free(f);
    }

    double k[3];
    size_t got = to_kelvin(c, 4, k, 3);
    for (size_t i = 0; i < got; i++)
        printf("%.2f ", k[i]);
    printf("(%zu values)\n", got);
    return 0;
}
פלט
23.0 32.0 70.7 212.0
268.15 273.15 294.65 (3 values)

בגרסת ה-Heap הקורא מקבל בלוק שחי עד שיקרא ל-free, וצריך לבדוק שלא חזר NULL. בגרסת החוצץ הקורא מחליט איפה הזיכרון יושב, ובדוגמה הוא קטן מהקלט, ולכן הפונקציה מדווחת בערך החזרה על 3 תאים בלבד.

תרחיש 3: החזרת שמונה מדידות חום

פונקציה צריכה למדוד שמונה פעמים ולהחזיר את התוצאות לקורא.

  1. בגרסה הלא נכונה הפונקציה מגדירה double out[8]; מקומי, ממלאת אותו ומחזירה את out.
  2. ברגע ה-return המסגרת נסגרת, והמערך חדל להתקיים. הקורא מחזיק כתובת במחסנית, באזור שפנוי לשימוש הקריאה הבאה.
  3. בגרסה הנכונה הפונקציה מבצעת malloc(8 * sizeof *out), בודקת שהתוצאה אינה NULL, ממלאת את הבלוק ומחזירה את המצביע.
  4. הבלוק יושב ב-Heap, ולכן הוא שורד את סגירת המסגרת. בתיעוד של הפונקציה כתוב שהקורא אחראי לשחרר את הבלוק ב-free כשהוא מסיים להשתמש בו.
טעויות נפוצות
  • משתנה מקומי נשאר בזיכרון עד שהתוכנית נגמרת. משך החיים שלו נגמר ביציאה מהבלוק או מהפונקציה שהגדירו אותו, ואז המקום שלו במסגרת מתפנה לשימוש אחר.
  • החזרת כתובת של מקומי מפילה את הבנייה בשגיאת קומפילציה. זו אזהרה בלבד (-Wreturn-local-addr), וקובץ ההרצה נבנה בכל זאת.
  • אחרי שהמשתנה נעלם, כל מצביע אליו הופך אוטומטית ל-NULL. שום מנגנון לא עוקב אחרי מצביעים כאלה. הכתובת הישנה נשארת בהם כמו שהיא.
  • const או register על משתנה מקומי מאריכים את חייו אחרי החזרה. אף אחד משני הרמזים אינו נוגע בשאלה אם המשתנה בכלל קיים אחרי היציאה.
  • משתנה מקומי הוא בלוק של Heap, ולכן צריך free לפני ה-return. הוא חי בתוך המסגרת ונעלם איתה בלי free. הפעלת free על כתובת כזאת היא התנהגות לא מוגדרת.
  • משתנים מקומיים נולדים עם הערך אפס. ערך התחלתי אפס מובטח רק לגלובליים ול-static. מקומי בלי אתחול מכיל מה שישב במקום הזה קודם.
בדקו את עצמכם
פונקציה next_ticket מגדירה static int ticket = 100;, מגדילה אותו ב-1 ומחזירה את &ticket. האם זה מצביע תלוי, ומה הבעיה האפשרית בכל זאת?

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

חזרה לתוכן העניינים

גודל מוגבל: Stack Overflow

למחסנית יש תקרה קבועה שנקבעת לפני שהתוכנית מתחילה לרוץ, והיא אינה גדלה לפי הצורך. ב-Linux ה-thread הראשי מקבל בדרך כלל 8MB (הפקודה ulimit -s מציגה את המספר). ב-Windows ברירת המחדל היא 1MB בבנייה עם MSVC, והמספר נקבע בזמן הקישור: קובץ ההרצה ש-MinGW יצר כאן שומר 2MB.

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

ב-Linux מתחת למחסנית ממתין דף שמירה (Guard Page): נגיעה בו שולחת לתהליך SIGSEGV (Segmentation Fault) והמערכת מסיימת אותו. ב-Windows נזרקת חריגה בשם STATUS_STACK_OVERFLOW (הקוד 0xC00000FD).

C
#include <stdio.h>

int main(void) {
    double samples[6000000];            /* 6,000,000 * 8 = 48 MB */
    samples[0] = 1.5;
    samples[5999999] = 2.5;
    printf("%.1f\n", samples[0] + samples[5999999]);
    return 0;
}

התוכנית הזאת מבקשת מסגרת של 48MB, הרבה מעבר לכל תקרה מקובלת, והיא נעצרת. בבדיקה שלנו (gcc -O0 על Windows) היא הסתיימה עם הקוד 0xC00000FD. עם -O2 הקומפיילר מוותר על המערך ומחשב את התשובה בלי להקצות אותו, ואז שום דבר לא נופל.

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

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

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

נתחיל מהרקורסיה: כל פונקציה רקורסיבית צריכה תנאי עצירה שמובטח שיתקיים, ואם העומק נקבע לפי קלט שהגיע מבחוץ צריך להגביל אותו במפורש. מנתח של קובץ מקונן, למשל, יכול לסרב ליותר מ-1,000 רמות.

חשוב גם גודל המסגרת: מערך מקומי של 4KB בכל רמה משאיר מקום לכ-2,000 רמות בלבד תחת תקרה של 8MB, והפונקציה בלי המערך מחזיקה הרבה יותר. משתנה static בפונקציה רקורסיבית אינו מוסיף מחיר לכל רמה, כי יש ממנו עותק יחיד שכל הרמות חולקות.

התקרה חלה על המחסנית ועליה בלבד: רקורסיה עמוקה אינה מצמצמת את ה-Heap, והקריאות ל-malloc ממשיכות לעבוד כרגיל.

תרחיש 4: רקורסיה שאין לה תנאי עצירה
C
#include <stdio.h>

int descend(int depth) {
    int scratch[8];
    scratch[0] = depth;
    if (depth % 8000 == 0) {
        printf("depth %d\n", depth);
        fflush(stdout);
    }
    return descend(depth + 1) + scratch[0];   /* no base case */
}

int main(void) {
    return descend(1);
}
פלט
depth 8000
depth 16000
depth 24000

קומפל עם gcc -O0 -Wall, ו--Wall הוא שמזהיר כאן על רקורסיה אינסופית. ב-Windows הודפסו שלוש שורות, כלומר הקריאה ה-24,000 כבר הייתה חיה, ומיד אחריהן התהליך נהרג עם הקוד 0xC00000FD. התקרה של קובץ ההרצה הזה היא 2MB, ולכן כל רמה תפסה בו פחות מ-90 בתים.

אותה ריצה ב-Linux, עם תקרה של 8MB, נגמרת בשלב אחר: המסגרות נערמות עד שמתחת לראש המחסנית נשאר רק דף השמירה, הקריאה הבאה נוגעת בו, והליבה מסיימת את התהליך ב-SIGSEGV. במעטפת רואים Segmentation fault, והתקרה שנקבעה מראש היא שהכריעה, לא מחסור במקום ב-Heap.

טעויות נפוצות
  • המחסנית מוסיפה לעצמה מקום ככל שהתוכנית דורשת. התקרה קבועה מראש. חציית התקרה הורגת את התהליך.
  • מערך מקומי עצום ימשיך לגדול מעבר למחסנית ויכתוב על ה-Heap. המחסנית גדלה כלפי מטה, ולפני שמגיעים לשאר המרחב ממתין דף השמירה.
  • מערך גדול במחסנית איטי כי צריך לסרוק רשימה של בלוקים פנויים. סריקה כזאת היא עבודה של מקצה ה-Heap. במחסנית יש רק הזזה של RSP.
  • static בתוך רקורסיה נוצר מחדש בכל רמת קריאה. יש רק עותק אחד, ב-data או ב-bss, שכל הרמות חולקות.
בדקו את עצמכם
פונקציה רקורסיבית שמסגרת אחת שלה תופסת כ-300 בתים נקראת לעומק של 40,000 רמות ב-Linux עם מחסנית של 8MB. מה יקרה, ומה אפשר לעשות?

העומק ידרוש כ-12MB, יותר מהתקרה, ולכן התוכנית תיפול ב-Segmentation Fault. אפשר להקטין את המסגרת, להגביל את העומק, להחליף את הרקורסיה בלולאה, או להעביר את הנתונים הגדולים ל-Heap.

חזרה לתוכן העניינים

VLA ו-alloca: הקצאה בזמן ריצה על המחסנית

מה ההבדל בין int a[100]; ל-int a[n];? בראשון הקומפיילר יודע את הגודל מראש. בשני, שנקרא VLA (Variable Length Array, מ-C99), הגודל נקבע בזמן ריצה, אבל המערך עדיין נבנה במחסנית ומסתיים בסוף הבלוק שבו הוגדר.

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

כל מה ש-alloca(size) מחזירה שייך למסגרת של הפונקציה שקראה לה, ולכן הוא נעלם רק כשהפונקציה חוזרת (ולא בסוף בלוק פנימי), אי אפשר לשחרר אותו ב-free, ואסור להחזיר אותו החוצה. הסיבה היא שזו קריאה לפונקציה שמרחיבה את המסגרת הנוכחית ב-size בתים ומחזירה כתובת לתוספת, בניגוד ל-VLA שהוא הצהרה.

גם alloca אינה יכולה להודיע על חוסר מקום: אין לה מידע כמה נשאר, והיא אינה מחזירה NULL. בקשה גדולה מדי מובילה ל-Stack Overflow בלי שום התראה. בנוסף היא אינה חלק מ-ISO C או מ-POSIX, אלא הרחבה של קומפיילרים.

שיטההיכןמה קורה בכשלמתי הבלוק נעלם
mallocHeapמחזירה NULL, והקוד יכול לבדוקכשקוראים ל-free
VLAמחסניתאין דיווח; חריגה היא התנהגות לא מוגדרת, לרוב קריסהבסוף הבלוק שבו הוגדר
allocaמחסניתאין דיווח, ואין NULL לבדוקכשהפונקציה חוזרת

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

תרחיש 5: אותו גודל, שתי שיטות

התוכנית מקבלת מספר מהשורה, מנסה קודם malloc ואחר כך VLA באותו גודל, ומדפיסה מה קרה. הנה שלוש ריצות של התוכנית, שקומפלה עם gcc -O0 -Wall:

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

int main(int argc, char **argv) {
    size_t n = strtoull(argv[1], NULL, 10);

    int *blk = malloc(n * sizeof *blk);
    if (blk == NULL) {
        printf("malloc refused %zu ints\n", n);
        return 1;
    }
    printf("malloc gave %zu ints\n", n);
    free(blk);
    fflush(stdout);

    int grid[n];                 /* VLA: the size comes from the command line */
    grid[n - 1] = 1;
    printf("VLA of %zu ints is alive: %d\n", n, grid[n - 1]);
    return 0;
}
פלט
$ ./vla 1000
malloc gave 1000 ints
VLA of 1000 ints is alive: 1
$ ./vla 5000000
malloc gave 5000000 ints
$ ./vla 400000000000
malloc refused 400000000000 ints

בקלט הקטן שתי השיטות מצליחות. עם כ-20MB (5,000,000 מספרים) malloc מצליחה, ואילו ה-VLA מפיל את התהליך בלי שורה אחת שאפשר לתפוס בה את הכשל (ב-Windows הקוד 0xC00000FD, ב-Linux Segmentation Fault). עם 400 מיליארד מספרים אפילו malloc מסרבת, אבל היא מחזירה NULL, והתוכנית מדפיסה הודעה ויוצאת בצורה מסודרת.

עם -O2 הקומפיילר יכול לוותר על ה-VLA ששימושו זניח, והריצה השנייה הייתה מצליחה. הכלל נשאר: כשהגודל מגיע מבחוץ, מקצים ב-Heap ובודקים NULL.

טעויות נפוצות
  • VLA מוקצה ב-Heap, ובכשל הוא מחזיר NULL. הוא נבנה במחסנית כמו כל מערך מקומי, ואין לו שום ערך החזרה.
  • כשל בהקצאת VLA מדווח דרך errno. אין קריאה שיכולה לדווח, ולכן errno אינו מתעדכן.
  • בקשה גדולה מדי ל-alloca מחזירה NULL, ואפשר לבדוק אותה. היא רק מזיזה את ראש המחסנית, בלי לדעת כמה מקום נשאר, ולכן אין לה ערך כשל. המחיר הוא Stack Overflow.
  • את בלוק ה-alloca חייבים לשחרר ב-free לפני חזרה מהפונקציה. הוא משתחרר לבד בחזרה, ו-free עליו היא התנהגות לא מוגדרת.
  • בסוף הפונקציה alloca מעבירה את הנתונים ל-Heap כדי שלא יאבדו. אין שום העברה: כשהמסגרת נסגרת הזיכרון שלה פנוי לשימוש הקריאה הבאה.
  • כשהקצאה נכשלת, malloc זורקת חריגה שאפשר לתפוס. ב-C אין חריגות. malloc מחזירה NULL.
בדקו את עצמכם
פונקציה קוראת ל-alloca(128), כותבת למקום שקיבלה נתונים ומחזירה את המצביע לקורא. מה לא בסדר?

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

חזרה לתוכן העניינים

גלישת חוצץ במחסנית (Stack Smashing)

דמיינו חוצץ (Buffer) כמו char code[12]; שיושב בתוך מסגרת. שפת C אינה בודקת אם הכתובת שאליה כותבים עדיין בתוך המערך, ולכן כתיבה של 13 בתים או יותר דורסת את מה שנמצא אחריו במסגרת.

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

Text
one frame, drawn with LOW addresses at the top (one possible layout)

  other locals               <- below the array here; the compiler chooses
  code[0]                    <- the write starts here
  code[1]
  ...                           and moves toward higher addresses
  code[11]                   <- last byte that belongs to the array
  (canary, if enabled)       <- directly below the saved RBP in gcc's layout
  saved RBP
  return address             <- ret takes its target from here

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

הבעיה אינה במחסנית עצמה אלא בכך שאיש אינו בודק גבולות: לא השפה ולא המעבד, והמחסנית אינה מתרחבת כדי לקלוט כתיבה עודפת. הפונקציות המסוכנות הן אלה שאינן מקבלות את גודל היעד, כמו gets (הוסרה מהתקן ב-C11) ו-strcpy ללא בדיקה, ואילו fgets ו-snprintf מקבלות אותו ועוצרות לפניו.

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

/* Vulnerable pattern, shown for review only: no length check. */
void show_code(const char *input) {
    char code[12];
    strcpy(code, input);          /* input longer than 11 chars runs past code */
    printf("code: %s\n", code);
}

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

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

/* Copies at most cap - 1 bytes and always terminates the result. */
void copy_label(char *dst, size_t cap, const char *src) {
    snprintf(dst, cap, "%s", src);
}

int main(void) {
    char label[12];
    char typed[64];

    if (fgets(typed, sizeof typed, stdin) == NULL)
        return 1;
    typed[strcspn(typed, "\n")] = '\0';

    copy_label(label, sizeof label, typed);
    printf("typed %zu chars, kept \"%s\" (%zu chars)\n",
           strlen(typed), label, strlen(label));
    return 0;
}
פלט
$ echo "ABC-17" | ./safe
typed 6 chars, kept "ABC-17" (6 chars)
$ echo "this-label-is-far-longer-than-twelve-bytes" | ./safe
typed 42 chars, kept "this-label-" (11 chars)

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

  • Stack Canary (הדגל -fstack-protector ב-gcc) הוא ערך שמירה אקראי שהקומפיילר מניח בין החוצץ לכתובת החזרה ומשווה אליו ברגע היציאה. הוא מזהה דריסה ואינו מונע אותה, ולכן עד שהשינוי מתגלה משתנים סמוכים כבר נדרסו. כשההשוואה נכשלת נקראת __stack_chk_fail, והתהליך מת עם הודעה שמכריזה על הדריסה: stack smashing detected.
  • NX (No-Execute) מסמן את דפי המחסנית כאסורים להרצה: בתים שהוזרמו אליהם לא ירוצו כהוראות. זה אינו מונע לדרוס את כתובת החזרה.
  • ASLR משנה בכל הרצה את מיקום המחסנית, ה-Heap והספריות, וכך קשה לנחש לאן להפנות קפיצה. הכתיבה החורגת עצמה ממשיכה לקרות.

ארבע תקלות שונות ששמותיהן דומים, ומה מבדיל ביניהן:

תקלהמה עושה הקודמה נפגע
Stack Smashing (Stack buffer overflow)כותב אחרי הסוף של מערך מקומימשתנים שכנים במסגרת ובעיקר כתובת החזרה
Stack Overflowמנצל את כל המחסנית: רקורסיה עמוקה או מערך ענקהתהליך נעצר בדף השמירה; שום כתובת חזרה לא נדרסת
Heap buffer overflowכותב אחרי הסוף של בלוק ב-Heapבלוקים סמוכים ורשומות הניהול של המקצה
קריאה מחוץ לגבולותקורא אחרי הסוף של מערך, בלי לכתובמידע שלא אמור להיחשף; הזיכרון עצמו אינו משתנה
תרחיש 6: 40 תווים לתוך חוצץ של 12 בתים

פונקציה מגדירה char code[12]; ומעתיקה אליו, בלי מגבלת אורך, קלט של 40 תווים. בפריסה שמדדנו עם gcc 16 (MinGW) על Windows ב--O0 ועם -fstack-protector, משבצת כתובת החזרה נמצאת 28 בתים אחרי תחילת המערך.

  1. 12 הבתים הראשונים ממלאים את המערך.
  2. 28 התווים הנותרים, ועוד תו הסיום, עוברים דרך ה-canary ומצביע המסגרת השמור ודורסים גם את כל משבצת כתובת החזרה.
  3. הדריסה קרתה בזמן ההעתקה, לפני שהפונקציה סיימה לרוץ, ולכן כל מה שבא אחר כך נשען על מסגרת פגומה.

מה יקרה ברגע היציאה תלוי במה שנבדק שם. בקוד שנבנה עם -fstack-protector ה-canary נדרס בדרך ואינו שווה עוד לערך המקורי, ולכן ההשוואה נכשלת והתהליך נעצר עם stack smashing detected לפני ה-ret. בקוד שנבנה בלי ההגנה שום בדיקה אינה מפריעה ל-ret, והיא קופצת לכתובת שהגיעה מהקלט: התנהגות לא מוגדרת, שבה מי ששלח את הקלט יכול להשפיע על המשך הריצה.

רק העתקה שמוגבלת לגודל היעד מונעת את התקלה. ה-canary, NX ו-ASLR נועדו לצמצם נזק, והם אינם מתקנים קוד פגום.

טעויות נפוצות
  • Stack Smashing היא רקורסיה עמוקה שממלאת את כל המחסנית. זה תיאור של Stack Overflow. Stack Smashing היא כתיבה אחרי סוף מערך מקומי שדורסת נתונים במסגרת.
  • Stack Smashing דורסת את רשומות הניהול של בלוקים ב-Heap. זו גלישת חוצץ ב-Heap, תקלה אחרת באזור אחר.
  • קריאה אחרי סוף מערך משנה את הערכים שמעבר לו. קריאה רק מציגה מה שכבר נמצא שם, ואינה משנה את הזיכרון.
  • המעבד עוצר כל כתיבה שחורגת מגודל המערך, עוד לפני הנזק. לא החומרה ולא השפה בודקות גבולות, ולכן הכתיבה מתבצעת כרגיל.
  • ה-canary עוצר את התוכנית בשורה שבה קרתה הגלישה. הוא נבדק רק לפני ret, אחרי שהכתיבה כבר דרסה את המסגרת.
בדקו את עצמכם
בפונקציה יש מערך char buf[8];, ובמסגרת, מעליו, משתנה int is_admin = 0;. קוד כותב 12 בתים ל-buf, והתוכנית קומפלה עם -fstack-protector. האם ה-canary שומר על is_admin?

לא. הדריסה של is_admin קורית בזמן הכתיבה, וה-canary נבדק רק בסוף הפונקציה, אחרי שהשינוי כבר נעשה. הוא מגן על כתובת החזרה בלבד. (ואם הקומפיילר מיקם את המשתנה מתחת למערך, בכלל אין לו מה לדרוס, כי המיקום בידי הקומפיילר.)

חזרה לתוכן העניינים

ה-Heap ומשפחת malloc

איך פועל ה-Heap ומי מנהל אותו

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

לבקשה משתמשים ב-malloc, ב-calloc או ב-realloc, ולהחזרה ב-free, שהיא הדרך היחידה לשחרר בלוק.

  • משך החיים: בלוק נשאר קיים עד שמשחררים אותו. הפונקציה שהקצתה אותו יכולה לחזור, והבלוק ממשיך להיות תפוס.
  • גישה: לבלוק אין שם. מגיעים אליו רק דרך כתובת ששמורה במצביע.
  • threads: כל ה-threads בתהליך חולקים מרחב כתובות אחד, ולכן בלוק שהוקצה בתוך thread אחד אפשר להשתמש בו ולשחרר אותו מ-thread אחר.
  • ניקוי: ל-C אין Garbage Collector, ולכן בלוק שנותרו אליו אפס מצביעים אינו נאסף לבד. הוא נשאר תפוס עד סוף התהליך.
השם Heap אינו קשור למבנה הנתונים heap (ערימה בינארית). זו רק מקריות של שם.

מה קורה כשהתוכנית קוראת ל-malloc? הקריאה מגיעה לפונקציית ספרייה ולא ישר לגרעין: זה המקצה (allocator) של ספריית C, שרץ בתוך התהליך (user space), וב-glibc הוא נקרא ptmalloc. הוא מחפש בלוק מתאים בין אזורים שכבר קיבל מהמערכת, ולכן את רוב הבקשות הקטנות הוא מספק לבד, בלי קריאת מערכת.

לכן malloc ו-free אינן קריאות מערכת אלא פונקציות ספרייה, ומגיעות לגרעין רק כשהמקצה צריך להשיג עוד זיכרון.

רק כשהמלאי אינו מספיק המקצה פונה לגרעין. לאזור ה-Heap הראשי הוא מוסיף מקום בקריאות brk או sbrk, ואת הבקשות הגדולות (מ-128KiB כברירת מחדל, סף שמשתנה דינמית לפי דפוס השימוש) הוא מקבל בנפרד באמצעות mmap.

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

טעויות נפוצות
  • משתנה מקומי שמוגדר בפונקציה, כמו int total = 0;, יושב ב-Heap משתנים מקומיים נוצרים במסגרת המחסנית של הקריאה. ב-Heap יש רק מה שביקשתם במפורש בפונקציית הקצאה.
  • המשתנים הגלובליים והסטטיים, וגם קוד המכונה של התוכנית, נשמרים ב-Heap משתנים גלובליים וסטטיים נמצאים במקטעים data ו-bss, והוראות המכונה במקטע text.
  • כשפונקציה חוזרת, הבלוקים שהקצתה נעלמים יחד עם המשתנים שלה רק מסגרת המחסנית מתפנה. בלוק ב-Heap נשאר תפוס עד קריאה ל-free או עד סוף התהליך.
חזרה לתוכן העניינים

הקצאה בבתים עם malloc ובדיקת כישלון

החתימה היא void *malloc(size_t size); והיא מוגדרת ב-<stdlib.h>. הפונקציה מחזירה כתובת של תחילת בלוק שגודלו לפחות size בתים, והיא מקבלת מספר בלבד: אין לה מושג מה אתם עומדים לאחסן שם.

מה יש בבלוק מיד אחרי ההקצאה? מה שהיה שם קודם: חלקים מבלוקים שנעשה בהם שימוש ושוחררו, ולפעמים במקרה אפסים.

malloc מקבלת מספר בתים בלבד ומחזירה void *, ולכן אינה יודעת לאיזה טיפוס הבלוק מיועד ואינה יכולה לאתחל אותו לפיו. הקומפיילר גם לא יעצור קריאה לפני כתיבה, ולכן אתחול (לולאה, memset או calloc) הוא עניינכם.

ומה לגבי cast? ב-C אין בו צורך, כי void * הופך למצביע המתאים מעצמו. רק ב-C++ חייבים לכתוב אותו.

  • מה אם אין זיכרון? malloc מחזירה NULL והתוכנית ממשיכה לרוץ, כך שההחלטה מה לעשות היא שלכם. דריפרנס של NULL (כתובת 0, שאינה ממופה) הוא התנהגות לא מוגדרת, ובדרך כלל הוא מסתיים ב-segmentation fault, ולכן בודקים לפני כל שימוש.
  • האם הצלחה מבטיחה זיכרון אמיתי? לא בלינוקס. בגלל overcommit המערכת מתחייבת לכתובות עוד לפני שיש מאחוריהן זיכרון פיזי, ואם הוא חסר, הכישלון יגיע רק בנגיעה בדפים, בדמות ה-OOM killer. לכן גם אז בודקים NULL.
  • באיזו כתובת מתחיל הבלוק? ב-glibc על x86-64 בכתובת שמתחלקת ב-16, והיא מתאימה לכל טיפוס סטנדרטי, כך שאין צורך לבדוק יישור.
  • ומה אם מבקשים 0 בתים? התקן משאיר זאת למימוש: NULL, או מצביע ייחודי שאסור לגשת דרכו. בבדיקה שלי על Windows עם MinGW gcc 16 וגם ב-glibc 2.35 התקבל מצביע ייחודי, שאפשר להעביר ל-free.
C
#include <stdio.h>
#include <stdlib.h>

enum { COUNT = 6 };

int main(void) {
    const size_t n = COUNT;
    unsigned *ids = malloc(n * sizeof *ids);
    if (ids == NULL) {
        fputs("no memory\n", stderr);
        return 1;
    }
    unsigned sum = 0;
    for (size_t i = 0; i < n; i++) {
        ids[i] = 1000 + 10 * (unsigned)i;
        sum += ids[i];
    }
    printf("last=%u sum=%u\n", ids[n - 1], sum);
    free(ids);
    ids = NULL;
    return 0;
}
פלט
last=1050 sum=6150

בביטוי n * sizeof *ids הערך sizeof *ids הוא גודל האיבר שהמצביע מצביע אליו, ושקול ל-sizeof(unsigned). כך הקוד נשאר נכון גם אם תשנו את טיפוס האיבר. במחרוזת מקצים תמיד strlen(s) + 1, כדי להשאיר מקום לתו הסיום '\0'.

למה לכתוב sizeof במקום מספר? התקן קובע ל-int רק מינימום של 16 סיביות, ולכן גודלו משתנה בין פלטפורמות: בדרך כלל 4 בתים ולפעמים 2. sizeof מוחלף בהידור בערך שמתאים ליעד, וגם חוסך טעויות ספירה ידניות.

שני דברים אחרים שכדאי להפריד: free אינה זקוקה ל-sizeof, כי הגודל שמור אצל המקצה, ו-malloc אינה דורשת שהארגומנט שלה יבוא דווקא מ-sizeof. היא מקבלת כל size_t, ולכן הקצאה קטנה מדי נבלעת בשקט, ולא הקומפיילר ולא מערכת ההפעלה יעצרו אותה. התקלה תתגלה רק כשתכתבו אל מעבר לקצה.

שורהמה קורה
double *t = malloc(8 * sizeof *t);נכון: 64 בתים, מקום לשמונה ערכי double
double *t = malloc(8);באג: 8 בתים בלבד, כלומר איבר אחד מתוך השמונה שתכננתם
short *t = malloc(sizeof(short));מתאים לאיבר בודד, לא למערך
char name[8] = malloc(8);שגיאת קומפילציה: אי אפשר לאתחל מערך מתוך כתובת
תרחיש 7: מספר קסם שנכתב ב-Windows ונשבר ב-Linux

מפתח כתב את השורה שבהמשך כי ב-Windows wchar_t תופס 2 בתים, והתוכנית עבדה אצלו. אחרי המעבר ל-Linux, שבו wchar_t הוא 4 בתים, עשרה תווים דורשים 40 בתים אבל הוקצו 20.

C
/* written on Windows, where wchar_t occupies 2 bytes */
wchar_t *title = malloc(10 * 2);

הקוד מתקמפל בלי אזהרה, והכתיבה מהאינדקס 5 ואילך חורגת מהבלוק. הכתיבה 10 * sizeof *title נותנת את הגודל הנכון בכל פלטפורמה.

טעויות נפוצות
  • בדיקת NULL אחרי malloc מוודאת שהבלוק התאפס, שהכתובת מיושרת או שהוא נמצא ב-Heap הבדיקה עונה על שאלה אחת בלבד: האם התבצעה הקצאה. התוכן אינו מאופס, היישור מובטח ממילא, והבלוק תמיד ב-Heap.
  • NULL פירושו בלוק שממתין לשחרור NULL אומר שלא הוקצה דבר, ולכן אין מה לשחרר.
  • malloc מאתחלת לפי הטיפוס: אפס ל-int ותו סיום ל-char היא לא יודעת לאיזה טיפוס ישמש הבלוק, והתוכן אינו מוגדר.
  • int הוא תמיד בגודל קבוע, ולכן אפשר לכתוב 4 או 8 במקום sizeof, ושל-free יש צורך בגודל הגודל תלוי בפלטפורמה ובקומפיילר, ו-free מוצאת את אורך הבלוק ב-metadata של המקצה.
בדקו את עצמכם
רוצים לשמור מחרוזת ש-strlen החזיר עבורה אורך 11, או מערך של 7 ערכי float על x86-64. כמה בתים יש לבקש מ-malloc בכל מקרה, והאם הם מאופסים?

עבור המחרוזת מבקשים 12 בתים (11 + 1 עבור '\0'), ועבור המערך 28 בתים (7 * 4). בשני המקרים התוכן ההתחלתי אינו מוגדר ואינו מאופס.

חזרה לתוכן העניינים

הבדל בין sizeof של מצביע לגודל ההקצאה

כדי להבין, התחילו ממערך: גודלו הוא חלק מהטיפוס שלו, ולכן sizeof נותן את כולו. משתנה מצביע, לעומת זאת, הוא כתובת בלבד, ו-sizeof שלו קבוע (8 בתים על x86-64) בלי קשר לכמות שהוקצתה, כי אף מקום בו אינו שומר את אורך הבלוק.

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

int main(void) {
    long long *vals = malloc(9 * sizeof *vals);
    char label[] = "gate";
    if (vals == NULL) return 1;
    printf("pointer=%zu element=%zu\n", sizeof(vals), sizeof(*vals));
    printf("array=%zu strlen=%zu\n", sizeof(label), strlen(label));
    free(vals);
    return 0;
}
פלט
pointer=8 element=8
array=5 strlen=4

בפלט sizeof(label) הוא 5 כולל תו הסיום, ואילו strlen סופרת עד התו הזה ונותנת 4.

מכאן שלכל בלוק דינמי צריך משתנה נפרד שמחזיק את מספר האיברים (count), ובו משתמשים בכל לולאה ובכל חישוב אורך. הנוסחה sizeof(arr) / sizeof(arr[0]) נכונה רק למערך אמיתי. על מצביע היא נותנת 8 חלקי גודל האיבר, כלומר 2 עבור int, בלי קשר לכמות שהוקצתה.

תרחיש 8: העתקה שמעבירה 8 בתים במקום 100
C
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main(void) {
    size_t count = 25;
    int *src = malloc(count * sizeof *src);
    int *copy = calloc(count, sizeof *copy);
    if (src == NULL || copy == NULL) return 1;
    for (size_t i = 0; i < count; i++) src[i] = (int)i + 1;

    memcpy(copy, src, sizeof(src));          /* bug: sizeof of a pointer */
    size_t copied = 0;
    for (size_t i = 0; i < count; i++) {
        if (copy[i] != 0) copied++;
    }
    printf("cells copied: %zu of %zu\n", copied, count);

    memcpy(copy, src, count * sizeof *src);  /* fix */
    printf("last cell after fix: %d\n", copy[count - 1]);
    free(src);
    free(copy);
    return 0;
}
פלט
cells copied: 2 of 25
last cell after fix: 25

בגרסה הראשונה sizeof(src) הוא גודל מצביע (8 בתים על x86-64), ולכן memcpy העתיקה 8 בתים, כלומר שני ערכי int, והשאירה 23 תאים מאופסים. gcc מזהיר על זה עם -Wall -Wextra (האזהרה -Wsizeof-pointer-memaccess), אבל רק במקרים פשוטים, ולכן ההגנה האמיתית היא להשתמש ב-count.

טעויות נפוצות
  • sizeof(ptr) מחזיר כמה בתים הוקצו ל-ptr הוא מחזיר את גודל המשתנה מצביע: 8 בתים בכל מערכת 64 סיביות, לא משנה כמה איברים הוקצו.
  • ב-x86-64 sizeof של int * הוא 4, כמו של int 4 הוא sizeof(*ptr), גודל האיבר. הכתובת עצמה תופסת 8 בתים.
בדקו את עצמכם
הקציתם long long *v = malloc(9 * sizeof *v); ב-x86-64. מה ערכם של sizeof(v) ושל sizeof(*v), וכמה בתים הוקצו?

sizeof(v) הוא 8 (גודל מצביע) ו-sizeof(*v) הוא 8 (גודל long long אחד), אבל הוקצו 72 בתים (9 * 8). השוויון בין שני הערכים מקרי: הם נמדדים על שני דברים שונים.

חזרה לתוכן העניינים

הקצאה מאופסת והגנה מגלישת כפל עם calloc

הפונקציה void *calloc(size_t n, size_t size); מקצה ב-Heap, בדיוק כמו malloc, בלוק של n * size בתים. שני דברים מייחדים אותה: היא מאפסת את כל הבתים, והיא מקבלת את הכמות ואת גודל האיבר בנפרד, כך שיכולה לבדוק את המכפלה (פרטים בהמשך). לדוגמה, calloc(6, sizeof(double)) נותנת 48 בתים מאופסים, מקום לשישה ערכי double, ולא 6 בתים.

הפרדת הארגומנטים חשובה כשהכמות מגיעה מבחוץ. נניח שקראתם מקובץ n = 2^62 + 3 וכתבתם malloc(n * 16): המכפלה מחושבת בקוד שלכם, ב-size_t של 64 סיביות, והערך האמיתי 2^66 + 48 נחתך מודולו 2^64 ונשאר 48.

malloc מקבלת 48 ומחזירה בלוק של שלושה איברים, אבל התוכנית בטוחה שיש לה n איברים, ולכן כל כתיבה אחרי השלישי היא Heap buffer overflow. הקומפיילר לא יכול לזהות זאת בהידור, כי n ידוע רק בזמן ריצה.

calloc מקבלת את n ואת 16 בנפרד, ולכן יכולה לבדוק בעצמה אם המכפלה חורגת מהטווח, ובמקרה כזה היא מחזירה NULL, שהבדיקה הרגילה שלכם תופסת. זו תכונה של הספרייה: הפלט שבהמשך הורץ ב-Windows עם MinGW gcc 16 (UCRT), ובבדיקה נפרדת של אותה קריאה ב-glibc 2.35 התקבל גם NULL. אל תניחו זאת בכל מערכת.

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

int main(void) {
    int *zeros = calloc(5, sizeof *zeros);
    if (zeros == NULL) return 1;
    int acc = 0;
    for (size_t k = 0; k < 5; k++) acc += zeros[k];
    printf("calloc(5, sizeof(int)) sum of cells: %d\n", acc);
    free(zeros);

    volatile size_t n = ((size_t)1 << 62) + 3;   /* e.g. a count read from a file */
    printf("n * 16 wraps to %zu\n", n * 16);
    void *viaCalloc = calloc(n, 16);
    printf("calloc(n, 16) returned NULL: %s\n", viaCalloc == NULL ? "yes" : "no");
    free(viaCalloc);
    return 0;
}
פלט
calloc(5, sizeof(int)) sum of cells: 0
n * 16 wraps to 48
calloc(n, 16) returned NULL: yes
נושאmalloccalloc
ארגומנטיםmalloc(size_t size): מספר בתים אחדcalloc(size_t n, size_t size): כמות וגודל איבר
מקום ההקצאהHeapHeap
מה בבלוקערכים לא מוגדריםאפסים בכל הבתים
המכפלה n * sizeמחושבת אצל הקורא, בלי בדיקהנבדקת בתוך הפונקציה, ובגלישה מוחזר NULL
טעויות נפוצות
  • calloc משאירה זבל בבלוק, ואילו malloc היא שמאפסת זה הפוך: calloc מאפסת, ו-malloc אינה מאתחלת דבר.
  • ההבדל בין השתיים הוא באזור: calloc מקצה על המחסנית ו-malloc ב-Heap שתיהן מקצות ב-Heap.
  • calloc(10, sizeof(int)) מבקשת 10 בתים היא מבקשת 10 * sizeof(int) בתים, 40 ב-x86-64.
  • גלישת n * size מתגלה בהידור, בשתי הפונקציות הגלישה נקבעת רק כשהתוכנית רצה, ו-malloc מקבלת מכפלה שכבר חושבה.
בדקו את עצמכם
אתם קוראים כמות n מקובץ קלט ומקצים n מבנים מסוג struct Entry שכל שדותיהם צריכים להתחיל ב-0. למה עדיף calloc(n, sizeof(struct Entry)) על פני malloc(n * sizeof(struct Entry))?

בגלל שני יתרונות יחד: calloc מאפסת את כל השדות ל-0, ובנוסף מזהה גלישה במכפלה n * sizeof(struct Entry) ומחזירה NULL במקום להקצות בלוק קטן מדי.

חזרה לתוכן העניינים

הגדלה והקטנה של בלוק עם realloc

הפונקציה void *realloc(void *p, size_t new_size); משנה את גודלו של בלוק שהוקצה קודם, ומחזירה את המקום שבו הוא יושב עכשיו. נעקוב אחרי בלוק של 4 ערכי int שהמצביע old מחזיק, שמגדילים ל-10 ומקבלים ב-grown.

  • אם יש מקום פנוי מיד אחרי הבלוק: הוא מתרחב במקומו, ו-grown שווה ל-old.
  • אם אין: נבנה בלוק חדש, ארבעת הערכים מועתקים אליו, והבלוק הישן מוחזר למקצה על ידי realloc עצמה. grown שונה מ-old, והתוצאה היא תמיד בלוק רציף אחד, ולא שני חלקים מחוברים.
  • התוכן בשני המקרים: ארבעת הערכים הראשונים שלמים, ושישה התאים החדשים מכילים שאריות, בלי איפוס. אותו עיקרון בהקטנה: נשמר מה שנכנס בגודל הקטן מבין השניים.
  • מה מחזיק כל מצביע אחרי הקריאה: רק grown מובטח. ייתכן ש-old כבר מצביע לבלוק שהוחזר, וכך גם כתובת פנימית שנשמרה קודם, כמו &old[1]. realloc לא יודעת שהם קיימים ולכן לא תתקן אותם, ואתם צריכים לחשב אותם מחדש מ-grown.
  • שחרור: בסוף קוראים ל-free(grown) פעם אחת. הוספת free(old) משחררת אותו בלוק פעמיים, כי אם הוא זז realloc כבר החזירה אותו, ואם לא זז הוא אותו בלוק.
  • כישלון: מוחזר NULL, והבלוק הישן ממשיך להיות תקף ותפוס. ההחלטה אם להמשיך לעבוד איתו או לשחרר אותו בידיכם.
  • ערכים מיוחדים: realloc(NULL, n) היא פשוט malloc(n). realloc(p, 0) נקבעת לפי המימוש (ובתקן C23 היא לא מוגדרת), ולכן לשחרור משתמשים רק ב-free.
C
#include <stdio.h>
#include <stdlib.h>

int main(void) {
    void *z = malloc(0);
    printf("malloc(0) is NULL: %s\n", z == NULL ? "yes" : "no");
    free(z);

    int *p = malloc(4 * sizeof *p);
    void *r = realloc(p, 0);
    printf("realloc(p, 0) returned NULL: %s\n", r == NULL ? "yes" : "no");
    free(r);

    int *fresh = realloc(NULL, 3 * sizeof *fresh);
    printf("realloc(NULL, n) gave a block: %s\n", fresh != NULL ? "yes" : "no");
    free(fresh);
    return 0;
}
פלט
malloc(0) is NULL: no
realloc(p, 0) returned NULL: yes
realloc(NULL, n) gave a block: yes

הפלט הזה הורץ ב-Windows עם MinGW gcc 16, וב-glibc 2.35 התקבלו אותן תוצאות בבדיקה נפרדת: realloc(p, 0) שחררה את הבלוק והחזירה NULL. ב-C23 קריאה כזו היא התנהגות לא מוגדרת, ולכן אל תסתמכו עליה.

הטעות הקלאסית היא p = realloc(p, n);. כשהקריאה נכשלת, NULL נכתב לתוך p והכתובת היחידה לבלוק הישן אובדת: הוא נשאר תפוס וחסר גישה, וזו דליפה. לכן מקבלים את התוצאה למצביע זמני, בודקים אותו, ורק בהצלחה מעדכנים את p, גם כשנדמה שהבלוק בוודאי יגדל במקום.

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

int main(void) {
    int *log_ids = malloc(3 * sizeof *log_ids);
    if (log_ids == NULL) return 1;
    log_ids[0] = 101;
    log_ids[1] = 102;
    log_ids[2] = 103;

    int *tmp = realloc(log_ids, 5 * sizeof *log_ids);
    if (tmp == NULL) {
        free(log_ids);
        return 1;
    }
    log_ids = tmp;
    log_ids[3] = 104;
    log_ids[4] = 105;
    printf("preserved=%d,%d added=%d\n", log_ids[0], log_ids[2], log_ids[4]);
    free(log_ids);
    log_ids = NULL;
    return 0;
}
פלט
preserved=101,103 added=105
תרחיש 9: מיקום בתוך בלוק שגדל

מנתח טקסט מחזיק מצביע cursor לתוך מאגר ואז מגדיל את המאגר. אם realloc העבירה אותו, cursor מצביע לבלוק ששוחרר, ולכן שומרים את ההיסט (offset) ולא את הכתובת, ומחשבים מחדש מהבסיס החדש.

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

int main(void) {
    char *buf = malloc(16);
    if (buf == NULL) return 1;
    strcpy(buf, "id=7;name=ron");
    char *cursor = buf + 5;                 /* points at "name" */
    size_t offset = (size_t)(cursor - buf); /* remember the position, not the address */

    char *bigger = realloc(buf, 4096);
    if (bigger == NULL) {
        free(buf);
        return 1;
    }
    buf = bigger;
    cursor = buf + offset;                  /* rebuild from the new base */
    printf("cursor sees: %.4s\n", cursor);
    free(buf);
    return 0;
}
פלט
cursor sees: name
טעויות נפוצות
  • realloc תמיד מרחיבה באותה כתובת היא מנסה קודם להרחיב במקום, אבל אם אין מקום צמוד היא מעבירה את הבלוק.
  • realloc תמיד מעבירה לבלוק חדש, אפילו כשיש מקום להמשיך באותה כתובת ההרחבה במקום היא הניסיון הראשון שלה, והעתקה נעשית רק כשצריך.
  • הגדלה עם realloc מוחקת את הנתונים הקיימים הערכים הישנים נשמרים. רק הבתים החדשים אינם מאותחלים.
  • בכישלון realloc משחררת את הבלוק הישן, ובהצלחה צריך free גם לישן וגם לחדש בכישלון הבלוק הישן נשאר תקף, ובהצלחה שתי קריאות free הן שחרור כפול.
  • realloc מעדכנת מצביעים אחרים שהצביעו לתוך הבלוק או מאפסת אותם היא לא יודעת עליהם, ולכן אלה שאתם מחזיקים בעצמכם חייבים להיות מחושבים מחדש.
בדקו את עצמכם
הגדלתם מערך של 4 ערכי int ל-10 עם realloc והיא הצליחה. מה בתאים 0 עד 3, מה בתאים 4 עד 9, והאם המצביע החדש שווה בהכרח לישן?

בתאים 0 עד 3 הערכים הישנים נשמרים. בתאים 4 עד 9 תוכן לא מאותחל, ואין להסתמך על ערך כלשהו. הכתובת עשויה להשתנות וגם להישאר, ולכן אין להניח דבר, ומשחררים רק את החדש.

קטנתם בלוק מ-8 ערכי double ל-3 עם realloc. מה קורה לשלושת הערכים הראשונים, ומה דינם של האחרים?

שלושת הראשונים נשמרים, כי התוכן נשמר עד הגודל הקטן מבין השניים. התאים 3 עד 7 כבר אינם חלק מהבלוק.

חזרה לתוכן העניינים

שחרור בלוק עם free והרגלי ניקוי בטוחים

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

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

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

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

struct Session {
    int id;
};

int main(void) {
    struct Session *s = malloc(sizeof *s);
    if (s == NULL) return 1;
    s->id = 7;
    printf("1) in use, id=%d\n", s->id);
    free(s);
    s = NULL;
    printf("2) after reset: %s\n", s == NULL ? "NULL" : "still an address");
    free(s);
    puts("3) the second free did nothing");
    return 0;
}
פלט
1) in use, id=7
2) after reset: NULL
3) the second free did nothing

בתוכנית שלמעלה, אחרי free(s) המשתנה עדיין מחזיק כתובת ישנה, אחרי s = NULL הוא ריק, והקריאה השנייה מקבלת NULL ולכן מסתיימת בלי לעשות דבר.

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

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

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

טעויות נפוצות
  • free מאפסת את תוכן הבלוק או את המצביע התוכן נשאר כפי שהיה, והאיפוס של המצביע הוא באחריות המתכנת.
  • free(NULL) היא שחרור כפול, שגיאת הידור או פקודה שמחזירה קוד שגיאה היא פעולה ריקה וחוקית, ו-free בכלל אינה מחזירה ערך.
  • כדי לדעת אם בלוק שוחרר, משווים את המצביע לערך שהיה בו לפני ה-free המצביע לא השתנה בקריאה, ולכן ההשוואה תמיד תצליח ואינה מוכיחה דבר.
  • הוספת const להצהרת המצביע חוסמת שימוש בו אחרי free const אינו קשור לתקופת החיים של הבלוק.
בדקו את עצמכם
העתקתם מצביע x למשתנה y, ואז ביצעתם free(x); x = NULL;. האם בטוח לקרוא מ-*y או לקרוא ל-free(y)?

לא. y עדיין מחזיק את הכתובת ששוחררה (מצביע תלוי, הנושא של הפרק הבא), ולכן קריאה דרכו היא שימוש בבלוק ששוחרר (Use After Free), ו-free(y) היא שחרור כפול (Double Free).

חזרה לתוכן העניינים

מתי בוחרים ב-Stack ומתי ב-Heap

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

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

נושאStackHeap
מי מקצההמהדר, בהזזת RSP בכניסה לפונקציההקוד שלכם, דרך malloc שמחפשת בלוק, מעדכנת נתוני ניהול ולעיתים פונה לגרעין
מי משחררהיציאה מהפונקציההקוד שלכם, ב-free
חיי הנתוניםנגמרים עם החזרהנמשכים עד free, גם אחרי החזרה
תקרת גודלקטנה (בדרך כלל 8MB בלינוקס)רחבה, כגודל הזיכרון הפנוי
כשנגמר המקוםאין דיווח, והחריגה מסתיימת ב-segmentation faultmalloc מחזירה NULL, שאפשר לבדוק
מחיר ההקצאהזניחגבוה יותר
שיתוף בין threadsלכל thread מחסנית משלותהליך אחד, Heap אחד לכולם
תרחיש 10: בחירת אזור זיכרון לארבעה שימושים
  • מערך עזר של 12 בתים לחישוב checksum בתוך פונקציה: Stack, כי הוא קטן, ידוע ואינו צריך לשרוד.
  • טבלת סשנים שנבנית בפונקציית אתחול ונשארת בשימוש עד סוף הריצה: Heap, כי היא חייבת לשרוד את חזרת הפונקציה.
  • תמונה של 4096 על 4096 פיקסלים בני 4 בתים (כ-67 מיליון בתים): Heap, כי היא גדולה בהרבה מ-8MB.
  • מאגר שאורכו מגיע בכותרת של הודעה מהרשת: Heap עם בדיקת NULL, כי הגודל ידוע רק בזמן ריצה ואי אפשר לבדוק כשל במחסנית.
טעויות נפוצות
  • כל קריאה ל-malloc היא קריאת מערכת שמאפסת את הזיכרון, ולכן היא איטית malloc אינה מאפסת, ורוב הבקשות הקטנות נענות מתוך אזורים שהמקצה כבר מחזיק, בלי פנייה לגרעין.
  • כדאי להשתמש במחסנית כשהגודל נקבע לפי קלט המשתמש המחסנית קטנה ואין דרך לבדוק בה כשל, ולכן קלט גדול יפיל את התוכנית.
חזרה לתוכן העניינים

באגים בזיכרון דינמי

דליפת זיכרון (Memory Leak): סיבות והשפעה

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

הנה הלולאה הבאה והתמונה שהמקצה רואה אחרי כל שלב.

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

int main(void) {
    char *line = NULL;
    for (int row = 0; row < 3; row++) {
        line = malloc(100);                  /* the previous block is dropped here */
        if (line == NULL) return 1;
        snprintf(line, 100, "row %d", row);
        puts(line);
    }
    free(line);                              /* releases only the last block */
    return 0;
}
פלט
row 0
row 1
row 2
שלבline מחזיקבלוקים תפוסיםבלוקים בלי אף כתובת
סיבוב 0AA0
סיבוב 1BA, B1 (A)
סיבוב 2CA, B, C2 (A, B)
אחרי free(line)כתובת של C, ששוחררA, B2 (A, B)

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

  • free נשכחת, בעיקר בנתיב שגיאה או ביציאה מוקדמת.
  • הכתובת היחידה נדרסת לפני השחרור, כמו בלולאה שלמעלה.
  • p = realloc(p, n); נכשלת וכותבת NULL על הכתובת הישנה.
  • פונקציה חוזרת, והמצביע לבלוק היה רק במשתנה מקומי שלה.
  • בשחרור רשימה מקושרת משחררים רק את הצומת הראשון.
תרחיש 11: דליפה רק בנתיב השגיאה
C
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int parse_port(const char *text) {
    char *tmp = malloc(strlen(text) + 1);
    if (tmp == NULL) return -1;
    strcpy(tmp, text);
    int port = atoi(tmp);
    if (port <= 0 || port > 65535) {
        return -1;                           /* early exit: tmp is never freed */
    }
    free(tmp);
    return port;
}

int main(void) {
    printf("%d %d\n", parse_port("8080"), parse_port("99999"));
    return 0;
}
פלט
8080 -1

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

התיקון הוא free(tmp) בכל נתיב יציאה, או מבנה עם יציאה אחת בסוף הפונקציה.

  • אין קריסה ואין segmentation fault, וקוד היציאה אינו משתנה.
  • בתוכנית ארוכה (שרת, לולאת עיבוד) צריכת הזיכרון גדלה בהדרגה, עד שהקצאות נכשלות או שכל המערכת סובלת ממחסור בזיכרון.
  • הדליפה נשארת ב-Heap: המחסנית אינה מתמלאת וקובץ ההרצה בדיסק אינו גדל.
  • בלוק שדלף נחשב תפוס, ולכן המקצה לא ימסור אותו שוב ולא תהיה דריסה של נתונים אחרים.
מי מנקה בסוף? מערכת ההפעלה, ורק כשהתהליך מסתיים: היא אוספת את כל הזיכרון שלו, כולל בלוקים שדלפו. אין צורך באתחול מחשב, והבלוקים לא עוברים לתהליך האב. כל עוד התוכנית רצה, אף מנגנון אינו סורק בלוקים נטושים, ולכן מי שמחפש דליפה משתמש בכלי ריצה כמו valgrind, שמפרט אילו הקצאות לא שוחררו.
טעויות נפוצות
  • דליפה היא free פעמיים על אותו מצביע, או שימוש בזיכרון שכבר שוחרר אלה Double Free ו-Use After Free. דליפה היא בלוק שלא שוחרר ולא נשארה אליו כתובת.
  • תוכנית שדולפת נעצרת מיד ב-Segmentation Fault, או שהזיכרון שדלף עובר למחסנית ומציף אותה דליפה שקטה ונשארת ב-Heap.
  • בלוק שדלף יוקצה שוב באותה כתובת ויידרס המקצה מחשיב אותו תפוס, ולכן אינו מוסר אותו.
  • הזיכרון שדלף נשאר תפוס אחרי סיום התוכנית, או שמערכת ההפעלה מפנה בזמן הריצה בלוקים שנעזבו בסיום התהליך הכול מוחזר, ובזמן הריצה אין מנגנון כזה.
בדקו את עצמכם
כלי עזר קצר מקצה 512 בתים ב-malloc ומסיים מיד בלי free. האם חלק מ-512 הבתים הללו יישאר תפוס במערכת ההפעלה אחרי שהכלי ייסגר?

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

חזרה לתוכן העניינים

השוואה בין מצביע תלוי, מצביע פרוע ומצביע NULL

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

מצבמה המצביע מכילאיך הגעתם לשםמה קורה בגישה דרכו
מצביע NULLכתובת 0, שאינה כתובת של אובייקטהושם בו NULL במפורש, או שפונקציה החזירה NULLבדיקה בתנאי חוקית. דריפרנס נכשל בדרך כלל מיד ובקול
מצביע פרוע (Wild)ערך מקרי שהיה במשתנה לפני שנכתב אליו משהוהצהרה על מצביע מקומי בלי ערך התחלתיהתנהגות לא מוגדרת: אולי קריסה, ואולי פגיעה בזיכרון של מישהו אחר
מצביע תלוי (Dangling)כתובת שהייתה תקפה ופג תוקפהfree, העברת הבלוק על ידי realloc, או סיום החיים של משתנה מקומיהתנהגות לא מוגדרת שנראית תמימה, כי הכתובת נראית אמיתית
דליפה (Leak)לא מצביע כלל: הבלוק תפוס ואין אף מצביע עליוהכתובת האחרונה נדרסה או אבדה לפני freeאין דרך לגשת אליו ואין דרך לשחרר אותו: כאן הזיכרון נשאר, והמצביע הוא שחסר

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

C
#include <stdio.h>

int *make_counter(void) {
    int count = 5;
    return &count;
}

int main(void) {
    int *c = make_counter();
    printf("%d\n", *c);
    return 0;
}
פלט
dang.c: In function 'make_counter':
dang.c:5:12: warning: function returns address of local variable [-Wreturn-local-addr]
    5 |     return &count;
      |            ^~~~~~

gcc 16 מדפיס את האזהרה שמעל גם בלי דגלים נוספים, והקוד עדיין מתקמפל. הרצת התוכנית היא התנהגות לא מוגדרת: היא עשויה להדפיס 5, ערך זבל או לקרוס (ב-MinGW בלי אופטימיזציה היא קרסה בהרצה שלי). מקרים שבהם הכתובת עוברת דרך כמה פונקציות כבר לא יזוהו.

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

טעויות נפוצות
  • מצביע שלא אותחל, מצביע שערכו NULL ומצביע שנדרס לפני free הם כולם Dangling הראשון פרוע (Wild), השני מצביע לכלום וניתן לבדיקה, והשלישי הוא דליפה.
  • מצביע תלוי קיים רק בזיכרון דינמי כל מצביע לזיכרון שפג תוקפו הוא תלוי, כולל כתובת של משתנה מקומי במחסנית אחרי חזרה מפונקציה.
בדקו את עצמכם
פונקציה מחזירה &local_val, או שבתוך בלוק פנימי מבוצע { int k = 9; ptr = &k; } ואחרי הסוגר קוראים את *ptr. איזה סוג מצביע הוא ptr?

מצביע תלוי (Dangling Pointer), כי המשתנה k על המחסנית חדל להתקיים בסוף הבלוק ו-ptr שומר את כתובתו הישנה.

חזרה לתוכן העניינים

Use After Free ושחרור כפול (Double Free)

שני מושגים שקל לבלבל: מצביע תלוי הוא מצב של משתנה שמחזיק כתובת שפג תוקפה, ו-Use After Free (UAF) היא פעולה, קריאה או כתיבה דרך אותו מצביע אחרי ה-free.

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

  • קריסה, מיד או הרבה אחר כך.
  • פגיעה שקטה בבעלים החדש של הבלוק, כשהמקצה כבר חילק את אותו מקום להקצאה אחרת.
  • שום דבר שנראה לעין: הערכים הישנים עדיין שם והכול נראה תקין.
C
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

struct Entry {
    char key[12];
    int hits;
};

int main(void) {
    struct Entry *cache = malloc(sizeof *cache);
    if (cache == NULL) return 1;
    strcpy(cache->key, "home");
    cache->hits = 3;

    struct Entry *view = cache;        /* a second name for the same block */
    free(cache);
    cache = NULL;                      /* resets only this variable */

    struct Entry *fresh = malloc(sizeof *fresh);
    if (fresh == NULL) return 1;
    strcpy(fresh->key, "login");
    fresh->hits = 0;

    view->hits = 99;                   /* use after free: view is dangling */
    printf("fresh: %s %d\n", fresh->key, fresh->hits);
    free(fresh);
    return 0;
}
פלט
uaf.c: In function 'main':
uaf.c:25:16: warning: pointer 'view' may be used after 'free' [-Wuse-after-free=]
   25 |     view->hits = 99;                   /* use after free: view is dangling */
      |     ~~~~~~~~~~~^~~~
uaf.c:17:5: note: call to 'free' here
   17 |     free(cache);
      |     ^~~~~~~~~~~

הפלט שמעל הוא האזהרה של gcc 16 על ה-UAF, והיא מופיעה עם -Wall (בלי דגלים היא נעלמת), ורק במקרה הפשוט הזה. בהרצה ב-Windows עם MinGW fresh לא קיבלה את הבלוק הישן, והתוכנית הדפיסה fresh: login 0. ב-glibc 2.35 נבדק שבלוק שהוחזר מוקצה שוב מיד, באותה כתובת, להקצאה הבאה באותו גודל, ואז הכתיבה דרך view הייתה משנה את fresh בשקט.

שחרור כפול (Double Free) מתרחש כשאותה כתובת בלוק מועברת ל-free יותר מפעם אחת, בין אם ברצף ובין אם עם קריאות אחרות ביניהן. זו התנהגות לא מוגדרת. המבנים הפנימיים שבהם המקצה מנהל בלוקים פנויים עלולים להתקלקל, ומכאן הדרך קצרה לקריסה או לפרצת אבטחה.

free מחזירה void, ולכן אין ערך שמסגיר זאת, ו-glibc מזהה חלק מהמקרים ועוצרת (בבדיקה על 2.35: free(): double free detected in tcache 2), אך אין הבטחה.

תרחיש 12: שחרור אחד בפונקציה ושחרור שני אצל הקורא
C
#include <stdio.h>
#include <stdlib.h>

struct Job {
    int id;
};

static void finish_job(struct Job *j) {
    printf("job %d done\n", j->id);
    free(j);
}

int main(void) {
    struct Job *j = malloc(sizeof *j);
    if (j == NULL) return 1;
    j->id = 4;
    finish_job(j);
    free(j);                  /* the callee already released this block */
    return 0;
}

הפונקציה finish_job משחררת את הבלוק, והקורא משחרר אותו שוב, כי המצביע נשלח לפי ערך ואינו מתאפס. בהרצה ב-Windows עם MinGW התהליך הסתיים עם קוד 0xC0000374 (heap corruption) והשורה job 4 done לא הופיעה, כי הפלט עוד לא נשטף. פתרון הוא כלל בעלות ברור: צד אחד בלבד משחרר.

מה רואים בקודשם התקלה
כתיבה או קריאה דרך מצביע אחרי ה-free שלוUse After Free
אותה כתובת של בלוק נשלחת ל-free פעמייםDouble Free
בלוק תפוס שנשארו אפס מצביעים אליוMemory Leak
כתיבה אל מעבר לקצה הבלוק או המערךBuffer Overflow
משתנה שמחזיק כתובת שפג תוקפהDangling Pointer
טעויות נפוצות
  • Use After Free נחסם בהידור או זורק חריגה בריצה המהדר לא עוצר זאת, ובשפת C אין חריגות.
  • הזיכרון ששוחרר מתאפס, ולכן הגישה מחזירה 0 free משאירה את הנתונים הישנים בזיכרון.
  • הקריאה השנייה ל-free מתעלמת בשקט או מחזירה קוד שגיאה היא התנהגות לא מוגדרת שעלולה להרוס את המקצה, ו-free מחזירה void.
בדקו את עצמכם
שחררתם בלוק עם free(ptr), ואז הדפסתם *ptr וקיבלתם את המספר המקורי שהיה בו. האם זה מוכיח שהבלוק עדיין שייך לכם?

לא. זו התנהגות לא מוגדרת שבה הערכים הישנים במקרה טרם נדרסו. הקצאה עתידית עלולה לקבל את אותו מקום ולשנות אותו.

חזרה לתוכן העניינים

אריתמטיקת מצביעים, גלישת גבולות ו-Heap Corruption

כשכתובת מחושבת ממצביע ומספר, החישוב נעשה באיברים: p + k מוסיף k * sizeof(*p) בתים. מצביע int מתקדם ב-4 בכל צעד, מצביע double ב-8, ורק char מתקדם בבית אחד. אותו כלל מסביר ש-p[i] הוא כתיבה אחרת של *(p + i).

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

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

int main(void) {
    int *samples = malloc(6 * sizeof *samples);
    if (samples == NULL) return 1;
    ptrdiff_t elem_gap = (samples + 5) - samples;
    ptrdiff_t byte_gap = (char *)(samples + 5) - (char *)samples;
    printf("elements=%td bytes=%td\n", elem_gap, byte_gap);
    free(samples);
    return 0;
}
פלט
elements=5 bytes=20

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

  • תנאי עצירה עם <= במקום <.
  • הקצאה של strlen(s) בלי + 1.
  • גודל שגוי ב-malloc, כמו מספר קבוע במקום sizeof.
  • אינדקסים שמחושבים ידנית בלי בדיקה.
תרחיש 13: בית אחד שחסר למחרוזת
C
const char *src = "gateway";          /* 7 characters */
char *tag = malloc(strlen(src));      /* bug: no room for the terminator */
strcpy(tag, src);                     /* writes 8 bytes into a 7-byte request */

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

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

הנזק אינו מורגש בשורה החורגת. הוא מתגלה כש-free(B) או malloc אחרת קוראות את הכותרת הפגומה: אז התוכנית נופלת (או ש-glibc עוצרת אותה), לפעמים הרבה זמן אחרי, ובקריאה שאין לה קשר לשורה הבעייתית. זו Heap Corruption, וקשה לאתר אותה בתוכנית גדולה.

משתנים גלובליים אינם חלק מה-Heap, כי הם יושבים ב-data וב-bss, והכתיבה החורגת לא פוגעת בהם.

כדי להחליט אם קטע קוד יכול לגרום ל-segmentation fault, שאלו אם הוא נוגע בכתובת שאינה ממופה או שאסור לכתוב אליה: דריפרנס של NULL, כתיבה לאזור קריאה בלבד, ולעיתים גישה ל-Heap מחוץ לבלוק או אחרי free. חישוב נטו (השמה של ערך עצום ל-double), קריאה חוקית ממערך גלובלי והחזקת NULL בלי להשתמש בו אינם נוגעים בכתובת פסולה. וכשכתובת שגויה כן ממופה, התוכנית עשויה להמשיך כאילו לא קרה דבר.
טעויות נפוצות
  • חיסור מצביעים מבלוקים שונים נותן את המרחק ביניהם בבתים, וקידום p + 1 מוסיף תמיד בית אחד קידום מתקדם ב-sizeof(*p) בתים, וחיסור בין בלוקים נפרדים הוא התנהגות לא מוגדרת.
  • כתיבה מעבר לסוף בלוק עוטפת לתחילתו, והקומפיילר בודק גבולות הכתיבה פוגעת בכתובת שאחרי הבלוק, ושום בדיקת גבולות לא מתבצעת.
  • Heap Corruption נעצרת מיד בשורה החורגת ההשחתה מתגלה לעיתים קרובות הרחק מהשורה שגרמה לה.
בדקו את עצמכם
הקציתם double *vec = malloc(3 * sizeof *vec); ב-x86-64. בכמה בתים גדולה הכתובת vec + 2 מ-vec, והאם גישה ל-vec[3] תקינה?

ב-16 בתים (2 * 8). גישה ל-vec[3] אסורה והיא התנהגות לא מוגדרת, כי האינדקסים החוקיים הם 0 עד 2 בלבד.

חזרה לתוכן העניינים

בעלות (Ownership) ושחרור מבנים מקושרים

נניח מודול קטן שמנהל הערות: note_create בונה אותן, note_length רק קוראת, ו-note_destroy משחררת. המוסכמה שמאחורי החלוקה נקראת Ownership, והיא עניין של הסכמה בין מתכנתים: אין לה פונקציית ספרייה, והמהדר אינו אוכף אותה.

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

struct Note {
    char *text;
};

/* Returns a new Note. The caller owns it and must pass it to note_destroy(). */
struct Note *note_create(const char *text) {
    struct Note *n = malloc(sizeof *n);
    if (n == NULL) return NULL;
    n->text = malloc(strlen(text) + 1);
    if (n->text == NULL) {
        free(n);
        return NULL;
    }
    strcpy(n->text, text);
    return n;
}

/* Borrowing: the pointer stays valid only while the owner keeps the Note. */
size_t note_length(const struct Note *n) {
    return strlen(n->text);
}

/* The owner releases the inner block first, then the Note itself. */
void note_destroy(struct Note *n) {
    if (n == NULL) return;
    free(n->text);
    free(n);
}

int main(void) {
    struct Note *memo = note_create("backup at 02:00");
    if (memo == NULL) return 1;
    printf("length=%zu\n", note_length(memo));
    note_destroy(memo);
    memo = NULL;
    return 0;
}
פלט
length=15
פונקציהמי מקצהמי משחררמה הקורא צריך לעשות
note_createהיא, בתוך הקריאהלא היאלקרוא לה, ולדעת שהוא הבעלים של התוצאה (הדבר מתועד בהערה מעליה)
note_lengthאף אחדלא היאלהעביר כתובת של הערה חיה, ולא לשחרר אותה אחרי
note_destroyאף אחדהיא, פעם אחת בדיוקלקרוא לה פעם אחת, ולא להשתמש בכתובת אחר כך

כלל השורה התחתונה: כל הקצאה מקבלת שחרור אחד, אצל הבעלים. אם כמה גורמים משחררים ליתר ביטחון, התוצאה היא Double Free.

מה כותבים בפונקציה שמחזירה בלוקלמה זה שגוי
free של הבלוק בשורה האחרונה ואז return NULLהקורא מקבל כלום, והפונקציה איבדה את תכליתה
החזרת מערך מקומיאחרי החזרה הוא מצביע תלוי
שום הערה על בעלות, מתוך הנחה שה-Heap מתפנה בסוף הפונקציהאין שחרור אוטומטי, ולכן זו דליפה

מקור נפוץ לבלבול בבעלות הוא העתקה של struct שמכיל מצביע. ההשמה מעתיקה את הכתובת ולא את הבלוק, ולכן שני העותקים חולקים בלוק אחד: כתיבה דרך האחד נראית בשני, ושחרור שניהם הוא Double Free. עותק עצמאי דורש העתקה עמוקה (הקצאה והעתקת התוכן), והפרטים בחלק על העתקת מבנים.

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

struct Device {
    char *tag;
};

int main(void) {
    struct Device d1, d2;
    d1.tag = malloc(10);
    if (d1.tag == NULL) return 1;
    strcpy(d1.tag, "sensorA");
    d2 = d1;
    d2.tag[6] = 'B';
    printf("d1.tag=%s\n", d1.tag);
    free(d1.tag);
    return 0;
}
פלט
d1.tag=sensorB

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

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

struct Task {
    int code;
    struct Task *next;
};

void free_tasks(struct Task *head) {
    while (head != NULL) {
        struct Task *upcoming = head->next;
        free(head);
        head = upcoming;
    }
}

int main(void) {
    struct Task *head = NULL;
    for (int k = 30; k >= 10; k -= 10) {
        struct Task *node = malloc(sizeof *node);
        if (node == NULL) {
            free_tasks(head);
            return 1;
        }
        node->code = k;
        node->next = head;
        head = node;
    }
    for (struct Task *cur = head; cur != NULL; cur = cur->next) {
        printf("%d ", cur->code);
    }
    printf("\n");
    free_tasks(head);
    return 0;
}
פלט
10 20 30
ניסיון לשחרר רשימהמה קורה בפועלאיך זה יתגלה
free(head) בלבדהצומת הראשון חוזר למקצה, והכתובת לשאר הרשימה אבדהדליפה של כל מה שאחריו
לולאה שמבצעת free(p) ואז p = p->nextהשדה next נקרא מצומת ששוחררUse After Free
איפוס כל מצביעי next ל-NULLהצמתים מנותקים, ואף בלוק אינו משוחררדליפה של כולם
הגדלת תקרת ה-Heap בהגדרות אינה פתרון: הדליפה ממשיכה לצבור, וההגדלה רק דוחה את רגע המחסור בזיכרון.
טעויות נפוצות
  • כל פונקציה שמקבלת מצביע צריכה לקרוא ל-free ליתר ביטחון שחרור מכמה מקומות גורם ל-Double Free. רק הבעלים משחרר.
  • Ownership היא פונקציה מובנית ב-C, או שקריאה אחת ל-free(head) משחררת את כל הרשימה Ownership היא מוסכמה של המתכנתים, ו-free משחררת בלוק בודד בלבד.
בדקו את עצמכם
בצומת של עץ יש מצביעים לשני בנים (left, right) וגם שדה char *label שהוקצה ב-malloc. באיזה סדר יש לשחרר?

תחילה משחררים רקורסיבית את left ואת right, לאחר מכן משחררים את label, ורק בסוף את הצומת עצמו (אחרת יאבדו המצביעים אליהם).

חזרה לתוכן העניינים

פיצול זיכרון, מקצים ייעודיים וכלי אבחון

פיצול זיכרון ב-Heap: פערים בחוץ ובזבוז בפנים

דמיינו חניון בן שבעה מקומות ששלושה מהם פנויים, אבל כל אחד מהם נמצא בין שתי מכוניות חונות. משאית שזקוקה לשני מקומות צמודים לא תיכנס, אף שיש שלושה מקומות פנויים. זה מה שקורה ל-Heap של תוכנית ארוכת טווח שמקצה ומשחררת בלוקים בגדלים משתנים, ותופעה זו נקראת פיצול זיכרון (Memory Fragmentation).

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

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

Text
[used 40][free 24][used 40][free 24][used 40][free 24]

sum of free holes = 72 bytes
max contiguous hole = 24 bytes
new request for 48 bytes -> fails to fit in any single hole

בפיצול פנימי (Internal Fragmentation) הבזבוז כלוא בתוך בלוק שכבר הוקצה. המקצה מעגל כל בקשה כלפי מעלה לפי יחידות הניהול שלו (ומוסיף כותרת ניהול פנימית), כך שאם ביקשתם 38 בתים ומקצה שמעגל לכפולות של 32 מחזיר בלוק של 64 בתים, 26 בתים בתוך הבלוק אינם מנוצלים.

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

תופעהמה קורה לזיכרון הפנויסיבת השורש וביטוי מעשי
דליפת זיכרון (Memory Leak)הולך ומתכווץ בהדרגהבלוקים שהוקצו לא שוחררו ב-free והמצביעים אליהם אבדו
פיצול פנימילא משתנה כלל: הבזבוז יושב בתוך בלוק תפוס ואינו מופיע כחור פנויעיגול בקשות כלפי מעלה משאיר בתים ריקים בתוך הבלוק
פיצול חיצוניהסכום הכולל מספיקחורים קטנים ולא רציפים מפוזרים בין בלוקים פעילים
מיצוי זיכרון כוללאזל בפועלמגבלת הזיכרון מוצתה ו-malloc מחזירה NULL
שחרור כתובת לא חוקיתאינו בעיית פיצולקריאה ל-free על כתובת זרה משחיתה את נתוני המקצה

כדי לצמצם פיצול פנימי כשהגדלים המבוקשים משתנים, המקצה מחזיק קבוצות של גדלים קבועים (size classes, ובשם אחר bins) במרווחים קטנים, למשל כל 16 בתים: 16, 32, 48, 64 וכן הלאה. בקשה מקבלת בלוק מהקבוצה הקטנה ביותר שעדיין מכילה אותה. הטבלה משווה שלוש שיטות על אותן שלוש בקשות, של 20, 70 ו-130 בתים (סך הכול 220 בתים, בלי לספור כותרות ניהול):

שיטהבלוקים שמוקציםבזבוז בתוך הבלוקים
קבוצות בקפיצות של 16 בתים32 + 80 + 144 = 25636 בתים
עיגול כל בקשה לעמוד של 4KB3 * 4096 = 1228812068 בתים
הקצאה מראש של גודל מרבי של 1000 בתים לכל אובייקט3 * 1000 = 30002780 בתים

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

תרחיש 14: שירות טלמטריה שנתקע מול בקשה רציפה

שרת איסוף נתונים מקצה לסירוגין 500 חוצצי הודעות של 200 בתים ו-500 רשומות מעקב של 32 בתים, ולאחר סיום העיבוד משחרר את כל החוצצים של 200 הבתים.

באופן תיאורטי התפנו כ-100KB, אך בפועל הם פרוסים ב-500 חורים של 200 בתים שביניהם תקועות רשומות של 32 בתים שעדיין בשימוש. כשהשרת מבקש חוצץ רציף של 10KB, אף חור אינו מספיק והמקצה נאלץ לפנות לגרעין לבקש זיכרון נוסף, אף שאפילו בית אחד לא דלף.

טעויות נפוצות
  • פיצול חיצוני נוצר רק כאשר קיימת דליפת זיכרון בתוכנית הוא מתרחש גם כשהקוד משחרר כל בלוק כחוק, פשוט עקב ערבוב של גדלים ותזמוני שחרור שונים.
  • פיצול פנימי הוא החורים שבין בלוקים ופיצול חיצוני הוא העודף שבתוך בלוק המינוח הפוך: פנימי הוא בתוך הבלוק שהוקצה, וחיצוני הוא המרווחים שבין הבלוקים.
  • פיצול הוא מצב שבו התוכנית שוכחת לשחרר זיכרון שכחת שחרור היא דליפת זיכרון; בפיצול הבלוקים כן שוחררו אך איבדו רציפות או נוצלו חלקית.
  • פיצול פנימי מתרחש במחסנית (Stack) שתי התופעות שייכות לניהול הדינמי ב-Heap.
בדקו את עצמכם
מקצה מחלק בקשות לקבוצות בגודל 32, 64 ו-128 בתים, ומקבל בקשה ל-65 בתים. איזו קבוצה תיבחר וכמה בתים יתבזבזו בפנים?

תיבחר הקבוצה של 128 בתים, כי 64 אינה מספיקה, ו-63 בתים יישארו לא מנוצלים בתוך הבלוק.

חזרה לתוכן העניינים

מקצים מותאמים אישית ו-Pool Allocator

במערכות זמן אמת ובמערכות משובצות (Embedded), לקריאות חוזרות ל-malloc ו-free יש שני חסרונות כבדים: זמן החיפוש והאיחוד של בלוקים אינו צפוי מראש, וה-Heap מתפצל לאורך ימי פעילות ארוכים. הפתרון הוא מקצה מותאם אישית (Custom Allocator): קוד שהמפתח כותב כדי לנהל יחידות זיכרון מתוך בלוק מרכזי יחיד (כגון מערך גלובלי או קריאה חד-פעמית ל-malloc).

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

Pool Allocator (מקצה מאגר) הוא המימוש הנפוץ של הרעיון: כל הבלוקים באותו גודל, והפנויים שבהם מחוברים ברשימה מקושרת (free list). אפשר ללוות בלוק אחד לאורך חייו: כל עוד הוא פנוי, שדה ה-next שבתוכו מחבר אותו לבא אחריו. כשלוקחים אותו, ראש הרשימה מתקדם לבלוק הבא, וכשמחזירים אותו הוא נכנס שוב לראש הרשימה, ולכן הבלוק שהוחזר הוא הראשון שיימסר בהקצאה הבאה.

C
#include <stdio.h>
#include <stddef.h>

#define POOL_CAP 3

struct job_slot {
    struct job_slot *next;   /* active only when slot is free */
    int priority;
    char tag[8];
};

static struct job_slot storage[POOL_CAP];
static struct job_slot *free_head = NULL;

void pool_setup(void) {
    for (int i = 0; i < POOL_CAP - 1; i++) {
        storage[i].next = &storage[i + 1];
    }
    storage[POOL_CAP - 1].next = NULL;
    free_head = &storage[0];
}

struct job_slot *slot_take(void) {
    struct job_slot *item = free_head;
    if (item != NULL) {
        free_head = item->next;
    }
    return item;   /* NULL if pool is full */
}

void slot_release(struct job_slot *item) {
    if (item == NULL) return;
    item->next = free_head;
    free_head = item;
}

int main(void) {
    pool_setup();
    struct job_slot *j1 = slot_take();
    struct job_slot *j2 = slot_take();
    struct job_slot *j3 = slot_take();
    struct job_slot *j4 = slot_take();   /* pool is now empty */

    j1->priority = 5;
    j2->priority = 9;
    printf("j1=%td j2=%td j3=%td j4=%s\n",
           j1 - storage, j2 - storage, j3 - storage,
           j4 == NULL ? "NULL" : "ok");

    slot_release(j2);
    struct job_slot *j5 = slot_take();
    printf("j5 reused slot=%td\n", j5 - storage);
    return 0;
}
פלט
j1=0 j2=1 j3=2 j4=NULL
j5 reused slot=1
נושאמה קורה במאגר
זמן פעולהשתי פעולות על מצביעים בלבד, בלי חיפוש חור ובלי איחוד שכנים, ולכן הזמן קבוע וצפוי מראש
פיצולאין: כל התאים זהים, ולכן כל תא פנוי מתאים לכל בקשה
בלוק ששוחררנשאר בבעלות המאגר וממתין לבא בתור; מערכת ההפעלה אינה מקבלת אותו בחזרה
אחריות המתכנתלהחזיר כל תא בפונקציית ההחזרה (בלי זה המאגר מתרוקן), לשמור על גבולות התא ולטפל במצב שבו הקיבולת הקבועה נגמרה
תוכן התאשאריות מהשימוש הקודם נשארות; אין איפוס כמו ב-calloc, ומי שצריך אפסים מאפס בעצמו
ניהול שוטףתאים חוזרים לרשימה במהלך הריצה; המאגר אינו שיטה של להשאיר הכול ולשחרר בבת אחת בסוף התהליך
תרחיש 15: עיבוד מסגרות שמע במעבד DSP

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

עבודה עם malloc לכל מסגרת תיצור תנודות בזמן התגובה ותפצל את ה-Heap. הקצאת Pool של 256 תאים מראש הופכת כל קבלה והחזרה של מסגרת להחלפת מצביע בודדת, וכשהמאגר מתמלא slot_take מחזירה NULL כדי שהקוד יפיל מסגרת בצורה מבוקרת.

טעויות נפוצות
  • שימוש ב-Pool Allocator מייתר את הקריאות להחזרת בלוקים ללא קריאה להחזרה (slot_release / pool_free), המאגר יתרוקן ויחזיר NULL.
  • בלוק שמשוחרר ב-Pool מוחזר מיד למערכת ההפעלה הוא חוזר לרשימה הפנויה בתוך המאגר כדי לשרת הקצאות נוספות.
  • המאגר מאפס את תוכן הבלוק לפני מסירתו כמו calloc הבלוק מכיל את השאריות מהשימוש הקודם, אלא אם המתכנת הוסיף איפוס מפורש.
  • מקצה מותאם אישית מעביר את ההקצאות למחסנית (Stack) המאגר יושב במערך סטטי או בבלוק יחיד מ-malloc, ולא במסגרת מחסנית של פונקציה.
בדקו את עצמכם
מדוע Pool Allocator אינו מתאים כאשר התוכנית מקצה אובייקטים שגדליהם נעים בין 8 בתים ל-4,000 בתים?

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

חזרה לתוכן העניינים

איתור תקלות זיכרון בזמן ריצה: valgrind ו-AddressSanitizer

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

כדי לדעת מה תוכנית עושה לזיכרון בפועל צריך להריץ אותה ולהסתכל, וזה ניתוח דינמי, ההפך מניתוח סטטי שקורא את הקוד לפני ההידור בלי להפעיל אותו. ב-Linux שני כלים משרתים אותו: valgrind (ברירת המחדל שלו היא memcheck) מפעיל אותה בתוך סביבת הרצה מבוקרת שרואה כל הקצאה, שחרור וגישה, ומאט אותה באופן ניכר, ואילו AddressSanitizer (הדגל -fsanitize=address ב-gcc או ב-clang) מוסיף בדיקות אל הקוד המהודר עצמו, וההאטה קטנה בהרבה.

Bash
gcc -g log_ingest.c -o log_ingest       # -g includes file names and line numbers
valgrind --leak-check=full ./log_ingest

# Faster alternative via compiler instrumentation:
gcc -g -fsanitize=address log_ingest.c -o log_ingest_asan
./log_ingest_asan

הידור עם הדגל -g גורם לדוח להציג שם קובץ ומספר שורה. הטבלה מראה אילו תקלות valgrind תופס ואיך כל אחת מופיעה:

מה קרה בתוכניתאיך זה נראה בדוח
כתיבה או קריאה מחוץ לבלוק, או גישה אחרי freeשורת Invalid write או Invalid read עם הגודל והמיקום ביחס לבלוק
שימוש בערך שלא אותחלאזהרה שתנאי או פעולה תלויים ב-uninitialised value
שחרור פגום: double free או כתובת שלא הגיעה מ-mallocשורת Invalid free, ובמקרה של שחרור כפול גם פרטי השחרור הקודם
בלוק שהוקצה ולא שוחרר עד הסוףבסיכום סוף הריצה: definitely lost ושרשרת הקריאות עד שורת ההקצאה

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

Text
==31042== Invalid write of size 4
==31042==    at 0x109198: parse_line (log_ingest.c:24)
==31042==  Address 0x4c21050 is 0 bytes after a block of size 16 alloc'd
==31042==    at 0x48407B4: malloc (vg_replace_malloc.c:381)
==31042==    by 0x109160: parse_line (log_ingest.c:19)
...
==31042== 128 bytes in 1 blocks are definitely lost in loss record 1 of 1
==31042==    at 0x48407B4: malloc (vg_replace_malloc.c:381)
==31042==    by 0x109210: open_batch (log_ingest.c:41)

קוראים את הדוח שורה אחר שורה: Invalid write of size 4 אומרת שנכתבו 4 בתים לכתובת פסולה, והשורה שאחריה מצביעה על הפונקציה והשורה בקוד שביצעו את הכתיבה (parse_line, שורה 24). 0 bytes after a block of size 16 מראה שהכתובת צמודה לסוף בלוק של 16 בתים, כלומר חריגה בדיוק מעבר לגבול, ושורות ה-malloc מתחתיה מציינות איפה הבלוק הוקצה (שורה 19). בסוף, 128 bytes in 1 blocks are definitely lost מציינת בלוק שהוקצה ואבד, יחד עם מקום ההקצאה שלו (open_batch, שורה 41).

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

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

מקמפלים עם -g ומריצים קובץ דוגמה קצר תחת valgrind --leak-check=full. בסיום הריצה מופיעה רשומת definitely lost המצביעה על השורה ב-open_batch שבה הוקצה הבלוק, ושם מתגלה סעיף return מוקדם שדילג על קריאת ה-free.

טעויות נפוצות
  • valgrind משחרר אוטומטית זיכרון שנשכח או מוסיף free לקוד הוא כלי מדווח בלבד ואינו משנה את התוכנית או מונע דליפות.
  • valgrind הוא מנתח סטטי שבודק את קובץ הקוד בלי להריץ אותו מדובר בניתוח דינמי שמריץ את התוכנית בפועל ובודק רק נתיבים שרצו.
  • valgrind מבודד מצביעים תלויים ומאפשר לתוכנית לרוץ איתם בבטחה הוא מדווח על הגישה הלא חוקית בזמן התרחשותה ואינו מסתיר אותה.
  • הרצה רגילה ב-gdb מפיקה רשימת הקצאות שלא שוחררו gdb הוא דיבאגר למעקב ושליטה בריצה, ואינו עוקב אחר דליפות כמו memcheck.
בדקו את עצמכם
חריגת גבולות ב-Heap מתרחשת רק כאשר קובץ ההגדרות מכיל שורה פגומה. האם הרצת valgrind על קובץ תקין תגלה את הבאג?

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

חזרה לתוכן העניינים

יישור זיכרון, ריפוד ופריסת struct ו-union

מדוע קיים יישור (Alignment) ומי קובע אותו

אם תגדירו struct שמכיל char ו-int ותבדקו את גודלו ב-x86-64, תגלו ש-sizeof מחזיר 8 בתים ולא 5. הסיבה לכך היא יישור זיכרון (Alignment): כתובתו של כל משתנה מטיפוס נתון חייבת להתחלק במספר קבוע של בתים.

חשבו על הזיכרון כעל שורה של תאים בגודל 4 בתים. int שמתחיל בכתובת 6 היה נשפך על שני תאים, ולכן לעיתים נדרשות שתי גישות במקום אחת. ב-x86 זה עדיין עובד, רק לאט יותר (למשל כשהנתון חוצה שורת מטמון), ובארכיטקטורות אחרות גישה כזו עלולה להיכשל בתקלת חומרה או להיות איטית בהרבה.

שאלהתשובה
מי קובע את היישור?הקומפיילר, ולא מערכת ההפעלה
מתי?כבר בהידור, בהתאם להגדרות ה-ABI של היעד; בזמן ריצה שום דבר לא משתנה
לפי מה?הטיפוס של כל שדה לחוד, ולא הגודל הכולל של המבנה
לשם מה?מהירות גישה. החיסכון במקום אינו המטרה, וברוב המקרים הריפוד דווקא מגדיל את המבנה

ב-x86-64 היישור של הטיפוסים הבסיסיים שווה בדיוק לגודל שלהם, כפי שהטבלה מראה:

טיפוס (ב-x86-64 Linux LP64)sizeof (בבתים)דרישת יישור
char11
short22
int, float44
long (Linux LP64; ב-Windows הוא 4)88
double88
כל מצביע (void *, int *)88
טעויות נפוצות
  • יישור זיכרון נועד להקטין את נפח המבנים בזיכרון היישור משפר את מהירות הגישה של המעבד, ובפועל הוא מגדיל מבנים בגלל הוספת ריפוד.
  • מערכת ההפעלה קובעת את יישור השדות בזמן ריצת התוכנית פריסת המבנה וההיסטים נקבעים כבר בזמן ההידור על ידי הקומפיילר לפי ה-ABI.
  • דרישת היישור נגזרת מהגודל הכולל של ה-struct לכל שדה יש דרישה לפי הטיפוס שלו, ויישור המבנה כולו הוא המקסימום מבין דרישות שדותיו.
חזרה לתוכן העניינים

ריפוד (Padding) וחישוב sizeof של struct

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

  1. אם הסמן אינו כפולה של דרישת היישור של טיפוס השדה, מזיזים אותו קדימה עד הכפולה הקרובה: אלה בתי הריפוד (padding).
  2. מניחים את השדה בסמן ומקדמים את הסמן בגודל השדה.
  3. בסוף יישור המבנה כולו הוא הגדול מבין יישורי השדות, והסמן מוזז עד הכפולה הקרובה שלו. התוצאה היא ה-sizeof, והבתים שנוספו בסוף הם ריפוד סופי.

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

Text
struct pkt_v1 { char type; double timestamp; char flags; };

offset: 0    1..7     8..15       16    17..23
bytes:  [ty | 7 pad | timestamp | flg | 7 pad ]
sum of fields = 10 bytes, sizeof(struct pkt_v1) = 24 bytes

הדוגמה הקלאסית היא struct { char a; int b; char c; }: a בהיסט 0, שלושה בתי ריפוד כדי שהיסט של b יתחלק ב-4, b בהיסטים 4 עד 7, c בהיסט 8, ואז מעגלים את 9 ל-12. סכום השדות הוא 6 ו-sizeof הוא 12, ואותם שדות בסדר int, char, char נותנים 8.

היישור של int הוא 4 ולא 8, ולכן struct { char c; int i; } ב-x86-64 הוא 8 בתים ולא 16. כדי לא לנחש, מבקשים מהקומפיילר את ההיסט עם המאקרו offsetof(type, member) מתוך <stddef.h>. מי שחייב פריסה צפופה יכול להשתמש בהרחבות כמו __attribute__((packed)) או #pragma pack, ומשלם בגישה לא מיושרת.

C
#include <stdio.h>
#include <stddef.h>

struct pkt_v1 {
    char type;
    double timestamp;
    char flags;
};

struct pkt_v2 {
    double timestamp;
    char type;
    char flags;
};

struct sensor_pkt {
    char ver;     /* size 1, align 1 */
    int seq;      /* size 4, align 4 */
    short crc;    /* size 2, align 2 */
    double ts;    /* size 8, align 8 */
};

int main(void) {
    printf("pkt_v1: sizeof=%zu ts=%zu flags=%zu\n",
           sizeof(struct pkt_v1),
           offsetof(struct pkt_v1, timestamp),
           offsetof(struct pkt_v1, flags));

    printf("pkt_v2: sizeof=%zu type=%zu flags=%zu\n",
           sizeof(struct pkt_v2),
           offsetof(struct pkt_v2, type),
           offsetof(struct pkt_v2, flags));

    printf("sensor_pkt: sizeof=%zu seq=%zu crc=%zu ts=%zu\n",
           sizeof(struct sensor_pkt),
           offsetof(struct sensor_pkt, seq),
           offsetof(struct sensor_pkt, crc),
           offsetof(struct sensor_pkt, ts));
    return 0;
}
פלט
pkt_v1: sizeof=24 ts=8 flags=16
pkt_v2: sizeof=16 type=8 flags=9
sensor_pkt: sizeof=24 seq=4 crc=8 ts=16
מבנה לדוגמה (x86-64 Linux, LP64; ב-Windows long הוא 4)מיפוי היסטיםsizeof
{ short a; int b; }a ב-0..1, 2 ריפוד, b ב-4..78
{ char a; short b; int c; }a ב-0, 1 ריפוד, b ב-2..3, c ב-4..78
{ double a; char b; int c; }a ב-0..7, b ב-8, 3 ריפוד, c ב-12..1516
{ char a; long b; short c; }a ב-0, 7 ריפוד, b ב-8..15, c ב-16..17, 6 ריפוד24
תרחיש 17: מעקב אחר ההיסטים של sensor_pkt

נתבונן במבנה sensor_pkt מהקוד למעלה: ver (char) יושב בהיסט 0. seq (int) דורש כפולה של 4, ולכן בתים 1..3 הם ריפוד ו-seq תופס את 4..7.

לאחריו crc (short) דורש כפולה של 2, והיסט 8 כבר זוגי, ולכן crc יושב ב-8..9 ללא ריפוד. כעת ts (double) דורש כפולה של 8, ולכן בתים 10..15 הם ריפוד, ts יושב ב-16..23, והגודל 24 כבר מתחלק ב-8 (היישור המרבי במבנה).

טעויות נפוצות
  • גודל של struct שווה תמיד לסכום הגדלים של איבריו הריפוד בין השדות ובסוף המבנה מגדיל לרוב את sizeof מעבר לסכום הפשוט.
  • הקומפיילר מסדר את השדות מחדש לפי גודל או סדר אלפביתי סדר ההצהרה נשמר תמיד; רק המתכנת יכול לשנות את הסדר בקוד המקור.
  • הקומפיילר מגדיל כל שדה לגודל השדה הרחב ביותר או ממזג שני char לתא אחד השדות שומרים על גודלם המקורי, והקומפיילר רק מוסיף בתי ריפוד ריקים.
  • הגודל של struct { char c; int i; } הוא 16 בתים היישור של int הוא 4 ולא 8, ולכן די ב-3 בתי ריפוד והתוצאה היא 8.
בדקו את עצמכם
מהו sizeof של struct { char a; double b; short c; char d; } בסביבת x86-64?

24 בתים. a בהיסט 0, בתים 1..7 ריפוד, b בהיסטים 8..15, c בהיסטים 16..17, d בהיסט 18, ובתים 19..23 ריפוד סופי כדי להגיע לכפולה של 8.

חזרה לתוכן העניינים

חישוב גודל של union ושימוש ב-tagged union

בחנו את union { char raw[5]; int n; }. שני השדות מתחילים בהיסט 0 ודורכים על אותם בתים, ולכן אין כאן חיבור של גדלים: הזיכרון חייב להכיל לפחות את השדה הגדול, כלומר 5 בתים, אבל int דורש יישור 4, ולכן הגודל עולה ל-8.

בכלל, sizeof של union הוא גודל השדה הגדול ביותר, מעוגל כלפי מעלה לכפולה של דרישת היישור המחמירה ביותר שבין השדות.

הגדרת union (x86-64 Linux, LP64; ב-Windows long הוא 4)חישוב גודל ויישורsizeof
{ char raw[7]; int val; }הגדול 7, יישור 4, עיגול לכפולה של 48
{ char buf[11]; int val; }הגדול 11, יישור 4, עיגול לכפולה של 412
{ short s; double d; }הגדול 8, יישור 88
{ char name[9]; long id; }הגדול 9, יישור 8, עיגול לכפולה של 816

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

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

לשם מה משלבים union עם תגית? כשערך יכול להיות מכמה סוגים, שדה enum נוסף, ה-tagged union, מציין איזה שדה תקף כרגע, והקוד קורא רק אותו. המהדר gcc ב-x86-64 מקצה ל-enum 4 בתים.

כש-union יושב בתוך struct, היישור שלו שווה ליישור המחמיר שבין שדותיו, והקומפיילר מניח אותו בהיסט שמתחלק בו. לכן יכול להיווצר ריפוד לפני ה-union, ולא רק אחריו.

C
#include <stdio.h>

union raw_buf {
    char bytes[7];
    int code;
};

struct wrapped {
    char active;
    union raw_buf payload;
};

struct token {
    enum { TOK_STR, TOK_INT } kind;   /* 4 bytes in gcc */
    union {
        char text[11];
        int number;
    } val;                            /* 11 rounded up to 12 */
};

union shared_word {
    int count;
    float ratio;
};

int main(void) {
    printf("raw_buf=%zu wrapped=%zu token=%zu\n",
           sizeof(union raw_buf),
           sizeof(struct wrapped),
           sizeof(struct token));

    union shared_word w;
    w.count = 42;
    w.ratio = 3.25f;   /* overwrites the shared 4 bytes */
    printf("count still 42? %d\n", w.count == 42);
    return 0;
}
פלט
raw_buf=8 wrapped=12 token=16
count still 42? 0

שימו לב ל-struct wrapped: השדה active יושב בהיסט 0, ו-payload דורש יישור של 4 (בזכות int code), ולכן נוספים 3 בתי ריפוד והגודל הכולל מגיע ל-12. ב-struct token התגית kind תופסת 4 בתים, ה-union בגודל 12 מתחיל מיד בהיסט 4 בלי ריפוד, והסך הכול הוא 16 בתים.

טעויות נפוצות
  • גודל של union הוא סכום גדלי שדותיו השדות חולקים את אותם בתים מהיסט 0 ואינם מונחים זה אחרי זה.
  • גודל ה-union שווה בדיוק לשדה הגדול ביותר ללא עיגול חובה לעגל כלפי מעלה לכפולה של היישור המחמיר ביותר ב-union.
  • כל שדה ב-union שומר את הערך שלו במקביל לשדות האחרים כתיבה לשדה אחד דורסת מיד את הנתונים של שאר השדות.
  • union בתוך struct מתחיל מיד אחרי השדה הקודם ללא ריפוד הוא מיושר לפי הדרישה המחמירה ביותר מבין איבריו הפנימיים.
בדקו את עצמכם
מהו sizeof של union { char code[17]; double weight; } בסביבת x86-64?

24 בתים. השדה הגדול הוא 17 בתים, והיישור המחמיר הוא 8 (של double), ולכן הגודל מתעגל לכפולה הבאה של 8.

חזרה לתוכן העניינים

מערך גמיש בסוף struct (Flexible Array Member)

מערך גמיש (Flexible Array Member, מתקן C99) הוא שדה אחרון ב-struct שמוצהר כמערך בלי מספר איברים, כמו double samples[];. הרעיון: כותרת קבועה ואיברים במספר שנקבע בזמן ריצה יושבים בבלוק רציף אחד, ולכן מספיקה קריאה אחת ל-malloc וקריאה אחת ל-free.

בחישובי הגודל יש לו שני צדדים: הוא אינו מוסיף אף בית ל-sizeof, אבל היישור של טיפוס האיברים שלו עדיין חל, גם על הריפוד שלפניו וגם על העיגול של הגודל הכולל.

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

struct frame {
    short kind;
    double samples[];   /* C99 flexible array member */
};

int main(void) {
    struct frame *f = malloc(sizeof(struct frame) + 4 * sizeof(double));
    if (f == NULL) return 1;
    f->kind = 7;
    f->samples[0] = 0.5;
    f->samples[3] = 4.5;
    printf("sizeof=%zu offset=%zu\n",
           sizeof(struct frame),
           offsetof(struct frame, samples));
    printf("kind=%hd last=%.1f\n", f->kind, f->samples[3]);
    free(f);
    return 0;
}
פלט
sizeof=8 offset=8
kind=7 last=4.5

בדוגמה זו kind (short) תופס את בתים 0..1, ו-samples דורש יישור 8 של double, ולכן נוספים 6 בתי ריפוד ו-offsetof(struct frame, samples) הוא 8. כיוון שהמערך עצמו אינו נספר, sizeof(struct frame) הוא 8 (ולא 2, ולא 16).

טעויות נפוצות
  • מערך גמיש נספר ב-sizeof כאילו הוא מכיל איבר אחד המערך אינו תורם כלל ל-sizeof של המבנה.
  • מערך גמיש אינו משפיע על היישור ועל הריפוד של המבנה היישור של איברי המערך קובע את הריפוד שלפניו ואת היישור הסופי של ה-struct.
בדקו את עצמכם
מהו sizeof של struct { double x; char bytes[]; } ב-x86-64?

8 בתים. המערך bytes אינו מוסיף לגודל, והיישור שלו (1) אינו מוסיף ריפוד מעבר ל-8 הבתים של double.

חזרה לתוכן העניינים

העתקה רדודה והעתקה עמוקה של מבנים

השמה רגילה (=) והעתקה רדודה

נסו לשרטט את הזיכרון אחרי alias = orig;. בשדה ה-int יש עכשיו שני עותקים עצמאיים של המספר. בשדה המצביע יש שתי כתובות זהות, ובסוף שתיהן ממתין בלוק אחד בלבד.

Text
orig.title  ---+
               +--> [ 'R' | 'e' | 'd' | '\0' ]   single block on Heap
alias.title ---+

אם alias.title[0] משתנה מ-'R' ל-'r', גם orig.title יציג "red", וכתיבה דרך orig נראית באותה מידה דרך alias. זו העתקה רדודה (Shallow Copy): מועתק הערך שיושב בשדה, ולא מה שנמצא מאחוריו.

עכשיו נחשוב על הניקוי. אם קוראים ל-free על orig.title ואחר כך על alias.title, אותו בלוק משוחרר פעמיים, ואם משחררים רק את הראשון וממשיכים להשתמש בשני, הוא מצביע תלוי. עד לשלב הזה אין שום סימן: ההשמה מתקמפלת, והכתובת שהועתקה תקפה.

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

טעויות נפוצות
  • השמה עם = מעתיקה גם את התוכן הדינמי שמאחורי שדות מצביע ההשמה מעתיקה רק את כתובת המצביע, ושני המבנים חולקים את אותו בלוק.
  • שפת C אוסרת להשים struct אחד לשני באמצעות = השמה בין מבנים מאותו טיפוס חוקית לגמרי (בניגוד להשוואה עם ==).
  • קריאה דרך המצביע של העותק היא מיד התנהגות לא מוגדרת כי לא הוקצה לו בלוק משלו הוא מחזיק כתובת חוקית של בלוק קיים ב-Heap, כל עוד המקור לא שוחרר.
חזרה לתוכן העניינים

כתיבת העתקה עמוקה ושחרור מדורג

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

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

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

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

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

struct label {
    char *text;
};

struct note {
    int id;
    char *body;
    struct label *tag;
};

/* Duplicates a C string into its own block; NULL on failure. */
static char *dup_str(const char *s) {
    size_t n = strlen(s) + 1;          /* characters + '\0' */
    char *p = malloc(n);
    if (p != NULL)
        memcpy(p, s, n);
    return p;
}

/* Releases every level; safe on a half-built object (calloc'ed members are NULL). */
void note_destroy(struct note *n) {
    if (n == NULL) return;
    if (n->tag != NULL) {
        free(n->tag->text);
        free(n->tag);
    }
    free(n->body);
    free(n);
}

struct note *note_clone(const struct note *src) {
    struct note *dst = calloc(1, sizeof *dst);
    if (dst == NULL) return NULL;
    dst->id = src->id;
    dst->body = dup_str(src->body);
    dst->tag = calloc(1, sizeof *dst->tag);
    if (dst->body == NULL || dst->tag == NULL) { note_destroy(dst); return NULL; }
    dst->tag->text = dup_str(src->tag->text);
    if (dst->tag->text == NULL) { note_destroy(dst); return NULL; }
    return dst;
}

int main(void) {
    struct label lb = { dup_str("todo") };
    struct note orig = { 7, dup_str("buy milk"), &lb };

    struct note shallow = orig;                       /* plain assignment */
    printf("shallow shares body: %d, shares tag: %d\n",
           shallow.body == orig.body, shallow.tag == orig.tag);

    struct note *deep = note_clone(&orig);
    if (deep == NULL) return 1;
    printf("deep shares body: %d, shares tag: %d\n",
           deep->body == orig.body, deep->tag == orig.tag);

    deep->body[0] = 'B';
    deep->tag->text[0] = 'T';
    printf("orig: %s / %s\n", orig.body, orig.tag->text);
    printf("deep: %s / %s\n", deep->body, deep->tag->text);

    note_destroy(deep);
    free(lb.text);
    free(orig.body);
    return 0;
}
פלט
shallow shares body: 1, shares tag: 1
deep shares body: 0, shares tag: 0
orig: buy milk / todo
deep: Buy milk / Todo

בפלט רואים את ההבדל: אחרי ההשמה הרגילה כל המצביעים משותפים, ואחרי note_clone אף אחד מהם אינו משותף. שינוי בעותק העמוק אינו נוגע במקור, ו-note_destroy משחררת רק את הבלוקים של העותק.

שימו לב לשני פרטים בקוד. מחרוזת משוכפלת ב-strlen(s) + 1 בתים כדי שה-'\0' יועתק איתה, וכשל באמצע ההעתקה מטופל בקריאה ל-note_destroy על עותק חלקי, וזה בטוח כי calloc איפסה את כל המצביעים ו-free(NULL) אינה עושה דבר.

טעויות נפוצות
  • בשפת C יש מתודת Clone מובנית שמבצעת שכפול עמוק למבנים אין שום תמיכה מובנית בשפה להעתקה עמוקה; יש לממש זאת בפונקציה ייעודית.
  • די להעתיק את השדות הסקלריים כי המהדר משכפל מצביעים פנימיים המהדר אינו מקצה זיכרון דינמי באופן אוטומטי עבור שדות מצביע.
בדקו את עצמכם
מבנה שמכיל int code ו-char *label מועתק בהשמה b = a, ולאחר מכן התוכנית קוראת ל-free(a.label) ול-free(b.label). מה קורה?

ההשמה העתיקה רק את הכתובת, ולכן שני השדות מצביעים לאותו בלוק ב-Heap. הקריאה השנייה ל-free היא שחרור כפול (double free) והתנהגות לא מוגדרת.

חזרה לתוכן העניינים

מחרוזות וטיפוס char בזיכרון

תו הסיום, sizeof מול strlen והקצאת n + 1

מחרוזת ב-C היא פשוט רצף של char שנגמר בבית שערכו 0, תו הסיום '\0'. אין טיפוס מחרוזת ואין מקום שבו נשמר האורך: הסוף נקבע אך ורק על ידי הבית הזה, ו-sizeof(char) הוא 1 בכל פלטפורמה לפי התקן.

לשאלה כמה גדולה המחרוזת יש שתי תשובות לגיטימיות. strlen עובדת בזמן ריצה: היא הולכת מההתחלה עד ה-'\0' הראשון וסופרת את מה שעברה, בלי התו עצמו.

sizeof אינו מריץ דבר: הקומפיילר כבר יודע כמה בתים תופס המערך כולו, כולל ה-'\0' והתאים הפנויים שאחריו במערך גדול, ולכן הערך קבוע בזמן ההידור. על char * הוא מחזיר 8 ב-64 ביט, גודל המצביע ולא גודל הבלוק.

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

int main(void) {
    char lang[] = "rust";       /* 4 chars + '\0' = 5 bytes */
    char split[] = "go\0py";     /* 5 chars + trailing '\0' = 6 bytes */
    char fixed[16] = "tcp";     /* fixed 16-byte array */
    char *dyn = malloc(64);     /* pointer is 8 bytes on 64-bit */
    if (dyn == NULL) return 1;

    printf("lang: sizeof=%zu strlen=%zu\n", sizeof(lang), strlen(lang));
    printf("split: sizeof=%zu strlen=%zu\n", sizeof(split), strlen(split));
    printf("fixed: sizeof=%zu strlen=%zu\n", sizeof(fixed), strlen(fixed));
    printf("dyn ptr sizeof=%zu\n", sizeof(dyn));

    lang[0] = 'R';
    strcpy(dyn, "udp");
    dyn[0] = 'U';
    printf("updated: %s %s\n", lang, dyn);

    free(dyn);
    return 0;
}
פלט
lang: sizeof=5 strlen=4
split: sizeof=6 strlen=2
fixed: sizeof=16 strlen=3
dyn ptr sizeof=8
updated: Rust Udp

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

C
char *dup = malloc(strlen(src) + 1);   /* characters + '\0' */
if (dup != NULL)
    strcpy(dup, src);                  /* the terminator is copied as well */
תרחיש 18: חריגה של בית אחד בהעתקת מחרוזת

מתכנת מקצה char *copy = malloc(strlen(src)); עבור src = "server" ומעתיק עם strcpy(copy, src);.

strlen("server") מחזירה 6, אך strcpy כותבת 6 תווים וגם את '\0', כלומר 7 בתים. הבית השביעי נכתב מחוץ לבלוק: התנהגות לא מוגדרת שעלולה להיראות תקינה בהרצה רגילה, אבל valgrind ידווח עליה כ-Invalid write of size 1. התיקון הוא malloc(strlen(src) + 1).

טעויות נפוצות
  • sizeof של char s[] = "hi"; מחזיר 2 הקומפיילר מוסיף בסוף את '\0', ולכן המערך תופס 3 בתים.
  • sizeof על מערך char מחזיר 8 כי מערך הוא מצביע מערך אינו מצביע: sizeof מחזיר את גודל המערך המלא, ו-8 הוא גודל של משתנה מצביע ב-64 ביט.
  • strlen סופרת גם את תו הסיום '\0' היא נעצרת ברגע שהיא פוגשת '\0' ואינה כוללת אותו בספירה.
  • הבית הנוסף ב-n + 1 שומר את אורך המחרוזת או מבטיח יישור תפקידו היחיד הוא להכיל את תו הסיום '\0'.
בדקו את עצמכם
נתון char buf[20] = "hello";. מה יחזירו sizeof(buf) ו-strlen(buf)?

sizeof(buf) הוא 20 (הגודל שהוצהר למערך), ו-strlen(buf) הוא 5 (מספר התווים עד '\0').

חזרה לתוכן העניינים

מערך char[] מול מצביע char * לליטרל

ציירו שני אזורי זיכרון. ב-char arr[] = "data"; יש מערך של חמישה בתים שהוא שלכם, ובתוכו עותק של הטקסט (על המחסנית אם המשתנה מקומי). ב-char *ptr = "data"; יש רק מצביע של 8 בתים, והוא מכוון לליטרל שהקומפיילר שמר באזור rodata לקריאה בלבד.

C
char arr[] = "data";   /* 5-byte writable array holding a copy; sizeof(arr) == 5 */
char *ptr = "data";    /* 8-byte pointer to a read-only literal; sizeof(ptr) == 8 */

arr[0] = 'D';          /* valid */
/* ptr[0] = 'D';       -> undefined behavior: writing to rodata (compiles fine) */

ננסה לכתוב בכל אחד. arr[0] = 'D' משנה בית בתוך המערך הפרטי, ושם הכול תקין. ptr[0] = 'D' עובר הידור בלי תלונה, כי הטיפוס char * מרשה כתיבה, ורק בזמן ריצה מנסים לכתוב לזיכרון לקריאה בלבד: התנהגות לא מוגדרת, שבדרך כלל מסתיימת ב-segmentation fault, אבל עלולה גם לפגוע בנתונים אחרים או לא להיראות בכלל.

שתי עובדות משלימות. מחרוזת במרכאות אינה תמיד קבועה: כשהיא רק מאתחלת מערך char[], היא מועתקת והעותק ניתן לעריכה. ואם רוצים שהקומפיילר יחסום כתיבה לליטרל כבר בהידור, מצהירים const char *ptr = "data";.

תרחיש 19: פונקציה שממירה אות ראשונה לאות קטנה

פונקציה void lower_first(char *s) { s[0] += 32; } נקראת פעמיים: פעם אחת עם char city[] = "Haifa"; ופעם שנייה עם char *lit = "Haifa";.

בקריאה הראשונה city הוא מערך מקומי שניתן לכתוב בו, והטקסט הופך ל-"haifa". בקריאה השנייה lit מצביע לליטרל ב-rodata, והכתיבה ל-s[0] היא התנהגות לא מוגדרת שב-Linux מסתיימת לרוב ב-segmentation fault.

טעויות נפוצות
  • שתי ההצהרות char s[] ו-char *p מצביעות לאותו ליטרל קבוע המערך s מקבל עותק עצמאי שניתן לשנות, ורק p מצביע לליטרל.
  • ניסיון לכתוב ל-p[0] ייכשל כבר בשלב ההידור ללא const, ההידור עובר בהצלחה והבאג מופיע כהתנהגות לא מוגדרת בזמן ריצה.
בדקו את עצמכם
נתון char *buf = malloc(6); strcpy(buf, "alpha"); buf[0] = 'A';. האם הכתיבה ל-buf[0] חוקית?

כן. buf מצביע לבלוק דינמי ב-Heap שהוקצה לתוכנית וניתן לכתיבה, ואליו הועתקו התווים מהליטרל.

חזרה לתוכן העניינים

סיכום

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

  • איפה הנתון חי? הקוד יושב ב-text, ליטרלים ב-rodata (קריאה בלבד), גלובליים ו-static ב-data או ב-bss, מה ש-malloc נותנת ב-Heap, ומקומיים ופרמטרים במסגרת מחסנית שנולדת בכל קריאה ונעלמת בחזרה ממנה. static מקומי אינו במחסנית ושומר ערך בין קריאות, ומצביע מקומי יושב במחסנית בעוד הבלוק שהוא מכוון אליו יושב ב-Heap.
  • למה המחסנית מהירה, ומה המחיר? הקצאה בה היא הזזה של RSP, ולכן היא מהירה ומשתחררת מעצמה. המחיר הוא גודל סופי (בערך 8MB ב-Linux ו-1MB ב-Windows) וצמיחה כלפי כתובות נמוכות: רקורסיה עמוקה, מערך מקומי ענק, VLA או alloca מגיעים ל-Stack Overflow, ב-Linux בדרך כלל כ-segmentation fault, ובלי NULL שאפשר לבדוק כמו ב-malloc. החזרת כתובת של משתנה מקומי יוצרת מצביע תלוי, ו-const או register אינם עוזרים, אבל הקצאה ב-Heap כן. כתיבה מעבר למערך מקומי (Stack Smashing) דורסת את כתובת החזרה, וה-canary מגלה זאת רק בסוף הפונקציה ואינו חוסם את הכתיבה.
  • איך משתמשים נכון ב-Heap? malloc(size) מחזירה בתים לא מאותחלים ו-NULL בכשל, בלי cast, והגודל תמיד n * sizeof של האיבר ולא sizeof של מצביע או מספר שנכתב ביד. calloc(n, size) מאפסת ובודקת גלישה של n * size. realloc שומרת את התוכן הקיים, משאירה את החלק החדש לא מאותחל, רשאית להזיז את הבלוק ומחזירה NULL בכשל בלי לשחרר את הישן, ולכן שומרים את התוצאה במצביע זמני ואחר כך עובדים רק איתו, כי כל מצביע אחר לבלוק הישן נעשה תלוי. free מחזירה void, אינה מאפסת תוכן או מצביע, free(NULL) חוקית וריקה, ואחריה מציבים NULL.
  • מה עלול להשתבש ב-Heap? דליפה היא בלוק שהמצביע אליו אבד: היא אינה גורמת לקריסה בעצמה, ומערכת ההפעלה אוספת את הזיכרון רק כשהתהליך מסתיים. מצביע תלוי מכוון לזיכרון שאינו בתוקף, מצביע פרוע לא אותחל מעולם, ו-NULL הוא ערך שאפשר לבדוק לפני גישה. גישה אחרי free, שחרור כפול וכתיבה מעבר לגבול הבלוק הם התנהגות לא מוגדרת, והאחרונה משחיתה נתוני ניהול ועלולה לקרוס הרחק מהשורה שגרמה לה. מונעים זאת בבעלות ברורה (לכל בלוק בעלים אחד, ופונקציה שמחזירה זיכרון מתעדת שהקורא משחרר) ובשחרור רשימה בלולאה ששומרת את next לפני ה-free.
  • איך מגלים, ומה עם פיצול? valgrind ו-AddressSanitizer מאתרים בזמן ריצה דליפות וגישות פסולות ומצביעים על השורה, אבל רק בנתיבי קוד שרצו. פיצול חיצוני הוא פרוסות פנויות בין בלוקים תפוסים, פיצול פנימי הוא בזבוז בתוך בלוק שהוקצה, ו-size classes מצמצמים את הפנימי. Pool Allocator נותן בלוקים בגודל קבוע מאזור שהוכן מראש, במהירות צפויה ובלי פיצול.
  • מה הגודל, ומה העותק? היישור נקבע בהידור לפי הטיפוס של כל שדה, לשם מהירות גישה. ב-struct נשמר סדר ההצהרה ומתווסף ריפוד לפני שדות ובסוף, ולכן sizeof לפחות כסכום השדות; union שווה לשדה הגדול ביותר מעוגל ליישור המחמיר; מערך גמיש אינו נספר בגודל אבל קובע יישור. השמת struct היא העתקה רדודה, והעתקה עמוקה דורשת פונקציה שמקצה ומעתיקה. במחרוזת sizeof סופר את '\0' ו-strlen לא, בהקצאה מוסיפים 1, ו-char[] הוא עותק שאפשר לשנות, בעוד char * לליטרל מכוון לזיכרון לקריאה בלבד.