שפת C - קוד
Memory Management in C
קטעי קוד ב-C על malloc, מצביעים, משתנים סטטיים וגדלי union ומבנים, עם קביעת הפלט.
בחרו את הרמה שמתאימה לכם ואת הסט שתרצו לתרגל
חומר לימוד
Memory Management in C: מעקב זיכרון, מחסנית, heap והקצאות דינמיות
שאלות קריאת קוד בניהול זיכרון ב-C מציגות תוכנית קצרה ומבקשות לקבוע מה היא מדפיסה או איך היא מתנהגת בזמן ריצה. כדי להגיע לתשובה הנכונה בלי לנחש, צריך לעקוב אחרי כל שורה ולדעת היכן נשמר כל נתון, מה משך החיים שלו ומה ערכו בכל רגע.
- שיטת מעקב והתנהגות לא מוגדרת: הפרדה בין טבלת המשתנים לתיבות הבלוקים, וזיהוי מדויק של מצבי Undefined Behavior מול שגיאות קומפילציה.
- מפת הזיכרון של התהליך: ההבדל בין המחסנית (stack), ה-
heap, אזור הנתונים הסטטי (.dataו-.bss) ואזור הקריאה בלבד (.rodata), כולל מיקום מצביעים, משתניstaticומסגרות רקורסיה. - מלכודות של משתנים מקומיים: החזרת כתובת מקומית, מצביע לא מאותחל ומערך מקומי גדול מדי שגורם לגלישת מחסנית.
- הקצאה ושינוי גודל: כללי
malloc,callocו-realloc, העברתint **לפונקציה, ושימוש נכון ב-free. - באגים, מחרוזות ומבנים: ארבעת הבאגים הקלאסיים בזיכרון דינמי, עבודה עם
charומחרוזות, חישוב גודל שלstructו-union(יישור, ריפוד ו-little endian), והבדל בין העתקה רדודה לעמוקה.
כל פונקציית ספרייה מלווה כאן בדוגמת קוד שהורצה בפועל ובמעקב שורה אחר שורה, כדי שתוכלו לזהות בקלות גם פלט תקין וגם מלכודות ריצה.
& ו-*. גדלי הטיפוסים בהסבר הם של x86-64 (64 סיביות) עם gcc: char תופס בית אחד, short תופס 2 בתים, int ו-float תופסים 4 בתים, ו-double וכל מצביע תופסים 8 בתים. הפלטים שמוצגים בהמשך הורצו ב-MinGW gcc 16 על Windows, ובכל פלט כתוב זאת. התנהגויות שתלויות ב-Linux וב-glibc, כמו מגבלת מחסנית של 8 MB או malloc(0), נבדקו ב-Linux בקריאה ישירה לספריית C מתוך Python, ולכן הן מתוארות בטקסט בלי בלוק פלט.איך עוקבים אחרי קוד שמנהל זיכרון
טבלת משתנים ותיבות של בלוקים
נסו לעקוב אחרי שלוש השורות int *a = malloc(sizeof *a); int *b = a; free(a);. מי שמניח ש-b הוא עותק של הנתונים, או שהוא הפך ל-NULL יחד עם a, ערבב בין החץ לבין מה שהחץ מראה עליו.
כדי לא ליפול בזה, מנהלים על הדף שתי רשימות נפרדות ולא אחת:
- טבלת משתנים: שורה לכל משתנה מקומי. ליד מצביע רושמים לאן החץ מכוון, או
NULLאם הוא לא מכוון לשום מקום. - תיבות: ריבוע ממוספר לכל הקצאה ב-
heap(בלוק 1, בלוק 2 ...), ובתוכו התאים והתוכן הנוכחי שלהם.
המטרה של כל מעקב: בסופו, כל תיבה שנפתחה נסגרה בקריאת free אחת בלבד, ושום חץ לא שימש לגישה לתיבה מחוקה או למקום מחוץ לתאים שלה. כדי להגיע לכך כל שורת קוד משנה את הדף באחת משלוש דרכים:
- קריאת הקצאה (
malloc,callocאוrealloc): מציירים תיבה חדשה וממוספרת. - השמה
q = pבין מצביעים: מוסיפים ל-qחץ אל אותה תיבה בדיוק, ושום תיבה לא נוספת ושום נתון לא מועתק. free(p): מוחקים את התיבה, אבל החצים נשארים כמו שהיו, גם שלpוגם של כל מצביע אחר שהראה עליה.
free נוסף דרכו, פוגעים בתיבה שאינה קיימת.תרחיש 1: מעקב בטבלה ובתיבות
#include <stdio.h>
#include <stdlib.h>
int main(void) {
int base = 5;
int *ptrA = malloc(sizeof *ptrA);
if (ptrA == NULL) return 1;
*ptrA = 12;
int *ptrB = ptrA;
*ptrB += base;
printf("%d %d\n", *ptrA, ptrA == ptrB);
free(ptrA); /* single block, single free */
return 0;
}17 1| פקודה | טבלת המשתנים | תיבות הבלוקים |
|---|---|---|
int base = 5; | base שווה 5 | עדיין אין תיבות |
int *ptrA = malloc(...) | ptrA מכוון לבלוק 1 | נפתח בלוק 1 עם תא אחד שאין עליו מידע |
*ptrA = 12; | אין שינוי בטבלה | התא של בלוק 1 מכיל 12 |
int *ptrB = ptrA; | ptrB מכוון גם הוא לבלוק 1 | לא נוספה תיבה |
*ptrB += base; | אין שינוי בטבלה | התא של בלוק 1 מכיל 17 |
printf(...) | מודפסים 17 (הערך של *ptrA) ו-1 (שני המצביעים שווים) | אין שינוי |
free(ptrA); | שני המצביעים שומרים את הכתובת הישנה | בלוק 1 הוסר |
למה לא לקרוא גם ל-free(ptrB)? כי יש כאן בלוק אחד בלבד, ו-free נספר לפי בלוקים ולא לפי מצביעים: הקריאה הראשונה כבר הסירה את בלוק 1, וקריאה שנייה תהיה שחרור כפול.
מאותה סיבה הכתיבה דרך ptrB נראתה גם ב-*ptrA, כי שני החצים מובילים לאותה תיבה. הפלט הורץ ב-MinGW gcc 16 על Windows.
כשהתשובה היא "התנהגות לא מוגדרת"
הביטוי התנהגות לא מוגדרת (Undefined Behavior, או UB) אומר שהתקן של C לא קובע מה יקרה, ולכן כל תוצאה לגיטימית: קריסה, מספר אקראי, הערך הישן, פגיעה בנתונים סמוכים או ריצה שנראית תקינה.
מזהה UB טיפוסי בקוד מופיע באחד משלושה תחומים:
- מחזור חיי בלוק דינמי: פנייה לזיכרון לאחר
free(use after free), שחרור חוזר של אותו בלוק (double free), או מסירת כתובת ל-freeשלא התקבלה מ-malloc,callocאוrealloc(למעטNULL). - גבולות ותוחלת חיים: חריגה מתחומי מערך או בלוק דינמי, ושימוש במצביע למשתנה מקומי או מערך מקומי אחרי שהפונקציה כבר הסתיימה.
- ערכים לא מאותחלים ואזורי קריאה בלבד: קריאה מתא
mallocאו משתנה מקומי לפני שנכתב אליו ערך, וכן ניסיון לשנות תו בתוך מחרוזת ליטרלית.
כדי לסנן במהירות אפשרויות שגויות במבחנים, זכרו שלוש עובדות על אופן הפעולה של C בזמן ריצה:
- שחרור שגוי אינו מדולג: הפונקציה
freeמתעלמת בשקט מ-NULLבלבד, ואינה מסננת כתובות שכבר שוחררו או כתובות מהמחסנית. - אין שום תוצאה מובטחת: תוכנית עם UB לא תתרסק בהכרח ולא תדפיס תמיד את הערך הישן (אף שלפעמים הערך הישן אכן נשאר בזיכרון במקרה).
- הבעיה מתגלה רק בריצה: המהדר אינו עוקב אחרי מצב הבלוקים וגודלם בזמן ריצה, ולכן הקוד מתקמפל כרגיל (לכל היותר עם אזהרה).
לפני שמתחילים לחשב פלט מספרי, בדקו תמיד אם מסתתר בקוד מצב של UB. רק לאחר שווידאתם שכל הגישות חוקיות, חשבו את הפלט המדויק.
טעויות נפוצות
- אם משחררים בלוק ומיד מדפיסים את תוכנו, יודפס הערך שהיה בו כי המחשב עוד לא דרס אותו. גם אם בהרצה מסוימת הערך הקודם נשאר במקרה בזיכרון, אין לכך שום הבטחה בתקן וזו התנהגות לא מוגדרת.
- השמה
ptrB = ptrAמשכפלת את הבלוק ומפרידה בין שני העותקים. ההשמה מעתיקה רק את הכתובת שבתוך המצביע. שני המצביעים ממשיכים להצביע לאותו בלוק יחיד. - קוד שיש בו שחרור כפול או חריגה מגבול מערך נכשל כבר בשלב הקומפילציה. הבעיה מתרחשת בזמן ריצה. המהדר יקבל את הקוד, ולכל היותר יציג אזהרה.
בדקו את עצמכם
תוכנית מבצעת שלוש הקצאות malloc, ומחזיקה חמישה מצביעים שונים שמכוונים לבלוקים הללו. כמה קריאות free נדרשות?
שלוש קריאות בלבד, אחת עבור כל בלוק שהוקצה. מספר המצביעים אינו משפיע על מספר התיבות.
פונקציה כותבת לבלוק אחרי שכבר קראה לו free, והתוכנית התקמפלה בלי שגיאה. האם הקוד תקין?
לא. עצם הקומפילציה אינה מבטיחה תקינות; כתיבה לאחר שחרור היא התנהגות לא מוגדרת בזמן ריצה.
איפה יושב כל נתון
מפת הזיכרון של תהליך
בזמן ריצה, מרחב הכתובות של התהליך מחולק למקטעים קבועים שלכל אחד מהם תפקיד ומשך חיים משלו. ב-x86-64 המחסנית מתרחבת כלפי כתובות נמוכות יותר, ואילו ה-heap מתרחב כלפי כתובות גבוהות יותר.
address space, lowest address first
.text machine code of the program (read-only)
.rodata string literals such as "abc" (read-only)
.data globals and statics with a non-zero start value
.bss globals and statics that start at zero
heap malloc / calloc / realloc blocks --> grows toward higher addresses
(free gap between heap and stack)
stack locals, parameters, return addresses <-- grows toward lower addresses| אזור זיכרון | מה נשמר בו | משך חיים |
|---|---|---|
מחסנית (stack) | משתנים מקומיים רגילים, פרמטרים וכתובות חזרה | מכניסה לפונקציה ועד סיומה |
ערימה (heap) | בלוקים דינמיים מ-malloc, calloc, realloc | מרגע ההקצאה ועד free (או סיום התהליך) |
data / bss | משתנים גלובליים ומשתני static מקומיים | לאורך כל ריצת התוכנית |
rodata | מחרוזות ליטרליות כגון "abc" (לקריאה בלבד) | לאורך כל ריצת התוכנית |
text | קוד המכונה של פונקציות התוכנית (לקריאה בלבד) | לאורך כל ריצת התוכנית |
קריאה או כתיבה בבלוק שכבר הוקצה ב-heap היא גישה רגילה לזיכרון, בלי תוספת עלות לכל גישה, כמו גישה למשתנה במחסנית. העלות היא בקריאות ההקצאה והשחרור, ובנוסף המיקום בזיכרון משפיע על מטמון המעבד (cache), כך שהמהירות בפועל אינה זהה תמיד. מה שקובע באיזה מקטע יישב משתנה הוא אופן ההגדרה או ההקצאה שלו, ולא הטיפוס שהוא מחזיק (int, char או מצביע).
מצביע מול הבלוק שהוא מצביע עליו
כשפונקציה מגדירה מצביע ומקצה לו זיכרון ב-malloc, נוצרים שני רכיבים בשני אזורים שונים: התא של המצביע עצמו (8 בתים של כתובת) יושב במסגרת המחסנית של הפונקציה, כלומר באזור שהמחסנית שומרת לה (stack frame), ורק הבלוק של הנתונים (*ptr) יושב ב-heap.
משתנה מקומי לעולם אינו עובר ל-heap. גם כשהמהדר, בגלל אופטימיזציה, מחזיק את המצביע באוגר של המעבד ולא בזיכרון המחסנית, הוא לא משנה את הכלל: רק בלוק שהוקצה בקריאה דינמית שייך ל-heap.
#include <stdlib.h>
int ratio = 3; /* data: global variable */
int compute(int x) { /* x: stack (parameter) */
static int count = 0; /* bss: static local, not on stack */
int total = x + ratio; /* total: stack */
int *buf = malloc(sizeof *buf); /* buf itself: stack (8 bytes) */
/* *buf (allocated int): heap */
if (buf == NULL) return -1;
*buf = total + count;
count++;
total = *buf;
free(buf);
return total;
}| אזור | פריטים בקוד של compute |
|---|---|
text | קוד המכונה של הפונקציה compute |
data / bss | המשתנה הגלובלי ratio והמשתנה הסטטי count |
heap | רק תא ה-int שהוקצה עבור *buf |
stack | הפרמטר x, המשתנה total והמצביע buf עצמו |
תרחיש 2: מה יושב באיזה אזור
#include <stdlib.h>
int main(void) {
int flag = 1; /* stack */
static int ready = 2; /* data */
char *tag = malloc(12); /* tag: stack, 12-byte block: heap */
const char *label = "done"; /* label: stack, "done": rodata */
free(tag);
return 0;
}| מה מוגדר | באיזה אזור | הערה |
|---|---|---|
int flag = 1; | stack | משתנה מקומי רגיל |
static int ready = 2; | .data | ערך התחלתי שונה מאפס, והמשתנה קיים לכל הריצה אף שהוגדר בתוך main |
המצביע tag | stack | 8 בתים של כתובת |
הבלוק של malloc(12) | heap | 12 בתים, והוא הפריט היחיד כאן שיושב ב-heap |
המצביע label | stack | 8 בתים של כתובת |
המחרוזת "done" | .rodata | אזור לקריאה בלבד |
מי ששואל מה יושב ב-heap בקוד הזה צריך לענות: 12 הבתים של tag בלבד.
משתנה static מקומי מול משתנה מקומי רגיל
המילה static לפני משתנה מקומי משנה את מיקומו ואת אורך חייו: במקום להיווצר על המחסנית בכל כניסה לפונקציה ולהימחק ביציאה ממנה, המשתנה מוקצה פעם אחת באזור הנתונים הסטטי (.bss כשערכו ההתחלתי הוא אפס או חסר, ו-.data כשיש לו ערך התחלתי שונה מאפס) ונשאר שם לכל משך הריצה.
בגלל שהקיום שלו אינו תלוי בקריאה ספציפית, שורה כמו static int acc = 0; אינה מאפסת את acc בכל פעם שהפונקציה רצה: האתחול קורה פעם אחת בלבד לפני תחילת הריצה, וכל קריאה רואה את הערך שהשאירה הקריאה הקודמת (בניגוד למשתנה מקומי אוטומטי שמתחיל מחדש בכל פעם).
תרחיש 3: מונה עם static ובלי static
#include <stdio.h>
int bias = 7; /* data: initialized global */
int step(void) {
static int acc = 0; /* bss: one instance, initialized once */
int cur = 0; /* stack: created anew on each call */
acc += 2;
cur += 2;
return acc * 10 + cur;
}
int main(void) {
int r1 = step();
int r2 = step();
int r3 = step();
printf("%d %d %d %d\n", r1, r2, r3, bias);
return 0;
}22 42 62 7| קריאה | acc אחרי += 2 | cur אחרי += 2 | ערך מוחזר |
|---|---|---|---|
| ראשונה | 2 | 2 | 22 |
| שנייה | 4 | 2 (נוצר מחדש מ-0) | 42 |
| שלישית | 6 | 2 (נוצר מחדש מ-0) | 62 |
אילו acc היה מתאפס בכל קריאה, הפלט היה 22 22 22. אילו cur היה שומר את ערכו כמו static, הפלט היה 22 44 66. הפלט הורץ ב-MinGW gcc 16 על Windows.
מכיוון שמשתנה static מקומי אינו נהרס בסיום הפונקציה, מותר בהחלט להחזיר את כתובתו. יתרה מזו, מכיוון שיש ממנו עותק יחיד בזיכרון, כל קריאה מחזירה בדיוק את אותה כתובת.
תרחיש 4: החזרת כתובת של מערך static
#include <stdio.h>
int *slot(void) {
static int arr[3] = {0, 0, 0};
arr[2] += 4;
return arr;
}
int main(void) {
int *first = slot();
int *second = slot();
printf("%d %d %d\n", first[2], second[2], first == second);
return 0;
}8 8 1הקריאה הראשונה מעלה את arr[2] ל-4, והשנייה מעלה אותו ל-8 ומחזירה שוב את אותה כתובת. בגלל ש-first ו-second מצביעים אל אותו מערך ממש, שניהם קוראים בסוף את הערך המעודכן 8. הפלט הורץ ב-MinGW gcc 16 על Windows.
מסגרת לכל קריאה: רקורסיה
אותה פונקציה רקורסיבית יכולה להדפיס 3 6 9 או 9 6 3, רק לפי המקום של שורת ההדפסה ביחס לקריאה העצמית. ההסבר הוא מסגרות המחסנית (stack frame): כל קריאה פותחת מסגרת חדשה מעל הקודמות ולא מוחקת אותן.
במסגרת יש עותק פרטי של הפרמטרים והמשתנים המקומיים, ולכן קריאות מקוננות לא דורסות זו את הערכים של זו. המסגרת שנפתחה אחרונה נסגרת ראשונה (LIFO), ומי שמדפיס אחרי הקריאה הרקורסיבית מקבל את הערכים מהקריאה העמוקה ביותר החוצה.
תרחיש 5: הדפסה לפני הרקורסיה ואחריה
#include <stdio.h>
void ascend(int n) {
int val = n * 3;
if (n > 1) {
ascend(n - 1);
}
printf("%d ", val);
}
void descend(int n) {
int val = n * 3;
printf("%d ", val);
if (n > 1) {
descend(n - 1);
}
}
int main(void) {
ascend(3);
printf("| ");
descend(3);
printf("\n");
return 0;
}3 6 9 | 9 6 3 ב-ascend(3) נפתחות שלוש מסגרות עם val = 9, val = 6 ו-val = 3. מכיוון שההדפסה מתבצעת רק אחרי החזרה מהקריאה הפנימית, ascend(1) מדפיסה ראשונה (3), אחריה ascend(2) (6) ובסוף ascend(3) (9), בעוד ב-descend ההדפסה קודמת לקריאה ולכן הסדר מתהפך. הפלט הורץ ב-MinGW gcc 16 על Windows.
טעויות נפוצות
- מצביע מקומי שנוצר ליד
mallocיושב גם הוא ב-heap. רק הבלוק המוקצה יושב ב-heap. המצביע עצמו הוא משתנה מקומי במחסנית. - משתנה
staticשמוגדר בתוך פונקציה נשמר במסגרת המחסנית שלה. משתנהstaticמקומי יושב באזור הנתונים הסטטי (.dataאו.bss) וחוצה קריאות. - פקודת אתחול כמו
static int acc = 0;מאפסת את המונה בכל כניסה לפונקציה. האתחול מתבצע פעם אחת בלבד ולא בכל קריאה. - אם ההדפסה כתובה אחרי הקריאה הרקורסיבית, הערכים יודפסו בסדר הכניסה לפונקציה. מסגרות המחסנית נסגרות בסדר הפוך (LIFO), ולכן הקריאה העמוקה ביותר מדפיסה ראשונה.
בדקו את עצמכם
בפונקציה מוגדרים int m = 1; static int k = 0; m += 3; k += 3; return m + k;. מה יחזירו שלוש קריאות רצופות?
7, 10, 13. המשתנה m מתאתחל מחדש ושווה תמיד 4, בעוד k מצטבר ל-3, 6 ו-9.
פונקציה מגדירה double *arr = malloc(4 * sizeof *arr);. כמה בתים נמצאים במחסנית וכמה ב-heap?
8 בתים של המצביע arr נמצאים במחסנית, ו-32 בתים (4 * 8) של הבלוק נמצאים ב-heap.
משתנים מקומיים: משך חיים ומלכודות
החזרת כתובת של משתנה מקומי
הקורא קיבל מצביע ויכול לנסות להשתמש בו, אבל הכתובת שבידו כבר לא שייכת לשום משתנה. משתנה מקומי רגיל ומערך מקומי חיים רק כל עוד הפונקציה פעילה, ובחזרה ממנה מסגרת המחסנית שלהם משתחררת וקריאה אחרת יכולה לתפוס את אותו מקום.
הפקודה return &local; מעבירה החוצה רק כתובת, ולא את הערך ולא את התא. התוצאה אצל הקורא נקראת מצביע תלוי (dangling pointer), וכל גישה דרכו היא התנהגות לא מוגדרת.
#include <stdio.h>
int *bad_num(void) {
int local = 99;
return &local; /* address of a local: dangling after return */
}
char *bad_str(void) {
char word[] = "sun"; /* array on the stack of bad_str */
return word;
}dangling.c: In function 'bad_num':
dangling.c:5:12: warning: function returns address of local variable [-Wreturn-local-addr]
5 | return &local; /* address of a local: dangling after return */
| ^~~~~~
dangling.c: In function 'bad_str':
dangling.c:10:12: warning: function returns address of local variable [-Wreturn-local-addr]
10 | return word;
| ^~~~הפלט למעלה הוא מה ש-gcc -c dangling.c מדפיס, בלי שום דגל נוסף, והוא הורץ ב-MinGW gcc 16 על Windows. יש בו שתי אזהרות מסוג -Wreturn-local-addr, אחת לכל פונקציה, כל אחת עם קובץ ומספר שורה. אין כאן שגיאה, ולכן הקובץ מתקמפל.
ב-gcc 16 יש תוספת: הוא מחליף את return &local; ב-return 0, כלומר שתי הפונקציות מחזירות כתובת אפס. לכן קריאה דרך התוצאה של bad_num נעצרת בכשל כבר ב--O0, ואין סיכוי לראות שם את 99.
זה מקרה של המהדר הזה. באופן כללי המחסנית אינה מתאפסת בחזרה מפונקציה ונשארת ממופה לתהליך, ולכן ערך ישן עשוי להופיע במקרה, אבל גם 0 או segmentation fault אפשריים, ואין שום הבטחה.
כדי להעביר כתובת החוצה, צריך זיכרון שחי יותר מהפונקציה. יש שלוש דרכים:
- לבקש בלוק ב-
heapב-mallocאו ב-calloc: הקורא מקבל את האחריות לקרוא ל-free. - להחזיר כתובת של משתנה
static, שקיים לאורך כל ריצת התוכנית. - להחזיר מצביע למחרוזת ליטרלית (
const char *s = "sun";) שיושבת ב-.rodataכל הריצה. לעומת זאתchar word[] = "sun";יוצר מערך מקומי במחסנית, והחזרתו אינה חוקית.
תרחיש 6: איזו החזרה תקינה
#include <stdlib.h>
int *f1(void) { int n = 7; return &n; } /* dangling: local */
int *f2(void) { static int n = 7; return &n; } /* valid: static */
int *f3(void) { /* valid: heap */
int *n = malloc(sizeof *n);
if (n) *n = 7;
return n;
}
char *f4(void) { char buf[] = "sky"; return buf; } /* dangling: array */
const char *f5(void) { const char *s = "sky"; return s; } /* valid: literal */f1 ו-f4 מחזירות כתובת מתוך מסגרת מחסנית שנמחקה. f2, f3 ו-f5 מחזירות כתובת לזיכרון שממשיך להתקיים גם אחרי החזרה; ב-f3 המצביע המקומי n נעלם, אבל הכתובת שבתוכו הוחזרה והבלוק ב-heap נשאר חי עד free.
מצביע מקומי שלא אותחל
בקוד הבא ההקצאה תלויה בתנאי, והתנאי כאן לא מתקיים:
int *ptr; /* uninitialized: holds garbage address, not NULL */
int mode = 1;
if (mode > 4) {
ptr = malloc(sizeof *ptr);
}
*ptr = 10; /* mode is 1, so ptr was never assigned: UB */בשורת ההגדרה ptr לא קיבל ערך, והתא שלו מחזיק את מה שנשאר במחסנית מהשימוש הקודם. זו כתובת אקראית (wild pointer), לא 0 ולא NULL, וכך מתנהג כל משתנה מקומי רגיל שלא אותחל.
כבר הכתיבה *ptr = 10; היא הגישה הלא חוקית, גם אם אחריה לא מודפס דבר. הקוד מתקמפל: בקטע הזה אין אזהרה ב--O0 גם עם -Wall, ו--Wuninitialized מופיעה רק כשמבקשים אופטימיזציה (-O1 ומעלה) יחד עם -Wall, ולכן אי אפשר להסתמך עליה.
ההרגל הבטוח הוא לכתוב int *ptr = NULL; כבר בהגדרה ולבדוק את המצביע לפני כל גישה. אותו כלל חל על תוכן: תאי בלוק מ-malloc אינם מאופסים, וקריאה מתא שלא נכתב היא קריאה של ערך לא מוגדר.
מערך מקומי ענק: Stack Overflow
למרות שמערכים מקומיים מוגדרים בתחביר רגיל של C, המקום במחסנית מוקצב בתקרה קשיחה (כ-8 MB לתהליכון הראשי ב-Linux, וכ-1 MB כברירת מחדל ב-Windows). מכיוון שכל תאי המערך המקומי מתמקמים ישירות בתוך מסגרת הפונקציה, הגדרת מערך שחורג מהתקרה מובילה לגלישת מחסנית (stack overflow).
גם רקורסיה עמוקה מדי או אינסופית מגיעה לאותה תוצאה, כי כל קריאה מוסיפה מסגרת עד שנגמר המקום. ב-Linux מתחת לקצה המחסנית יש דף שמור (guard page): הגעה אליו מפעילה את מערכת ההפעלה, והיא עוצרת את התהליך עם הודעת segmentation fault (האות SIGSEGV).
void build_grid(void) {
int matrix[2500][1000]; /* 2500 * 1000 * 4 = 10,000,000 bytes (~10 MB) */
matrix[0][0] = 1;
}בדוגמה של build_grid, המערך תופס כ-10 MB וחורג ממגבלת 8 MB, ולכן בהרצה רגילה על Linux (בבנייה ללא אופטימיזציה) הקריאה לפונקציה תסתיים ב-segmentation fault. הקוד עצמו תקין מבחינה תחבירית ומתקמפל בלי שגיאה, כי המהדר אינו מעביר מיוזמתו מערך גדול ל-heap.
שימו לב שאין כאן "דליפת זיכרון" ואין שחרור ב-free, משום שהמערך לא הוקצה ב-heap; כדי לפתור את הבעיה מעבירים אותו להקצאה דינמית עם malloc או מסמנים אותו כ-static או גלובלי.
טעויות נפוצות
- כשפונקציה מחזירה כתובת של מערך מקומי, הערכים מועתקים אוטומטית לפונקציה הקוראת. פקודת
returnמחזירה רק את הכתובת, והמערך עצמו נמחק עם מסגרת המחסנית. - החזרת כתובת של משתנה מקומי נדחית בשגיאת קומפילציה. המהדר מוציא אזהרה בלבד ומייצר קוד שמתקמפל.
- מצביע מקומי שלא קיבל ערך מתחיל אוטומטית כ-
NULL. משתנים מקומיים אינם מאופסים; הוא מכיל זבל אקראי. - מערך מקומי ענק גורם לדליפת זיכרון כי לא קוראים לו
free. מערכים מקומיים אינם ב-heapואינם עובריםfree. הבעיה היא גלישת מחסנית (stack overflow). - אחרי החזרה מפונקציה המחסנית מתאפסת, ולכן קריאה דרך מצביע תלוי תחזיר תמיד
0. אין איפוס אוטומטי. הזיכרון נשאר ממופה ועשוי להכיל את הערך הישן, אפס או לגרום לקריסה, ואין הבטחה לאף אחת מהתוצאות.
בדקו את עצמכם
פונקציה מגדירה static char line[32]; ומחזירה את line. האם המצביע תקין אצל הקורא?
כן. בזכות static המערך יושב באזור הנתונים הסטטי וחי לאורך כל התוכנית.
מה יקרה ב-Linux בפונקציה שמגדירה מערך מקומי int huge[4000000]; (כ-16 MB) וכותבת אל huge[0]?
המערך חורג ממגבלת המחסנית של 8 MB, גורם לגלישת מחסנית והתהליך נהרג ב-segmentation fault.
malloc ו-calloc
malloc סופרת בתים, לא איברים
הקריאה malloc(4) נראית כמו בקשה לארבעה מספרים, אבל היא מבקשת ארבעה בתים, כלומר מקום ל-int אחד בלבד. ההצהרה היא void *malloc(size_t size); (מתוך <stdlib.h>), והארגומנט הוא תמיד כמות בתים.
כדי לקבל n תאים מכפילים בגודל תא אחד: malloc(n * sizeof(int)), או עדיף malloc(n * sizeof *p). הערך של sizeof *p נקבע בקומפילציה מהטיפוס של p ואינו ניגש לזיכרון, ולכן הוא תקין גם כש-p עוד לא מצביע לשום דבר.
התוצאה היא מצביע לתחילת בלוק ב-heap בגודל size בתים לפחות, או NULL כשההקצאה נכשלת. תוכן הבלוק אינו מאופס, וקריאה מתא שלא נכתב היא UB. אין צורך בהמרה מפורשת כמו (int*)malloc(...), כי void * מומר אוטומטית לכל מצביע (ההמרה חוקית אך מיותרת).
תרחיש 7: כמה בתים הוקצו
#include <stdio.h>
#include <stdlib.h>
int main(void) {
short *s = malloc(5 * sizeof *s);
double *d = malloc(3 * sizeof(double));
char *b = malloc(9);
if (!s || !d || !b) return 1;
printf("%zu %zu %zu\n", 5 * sizeof *s, 3 * sizeof(double), sizeof(char) * 9);
printf("%zu %zu %zu\n", sizeof s, sizeof d, sizeof b);
free(s);
free(d);
free(b);
return 0;
}10 24 9
8 8 8האופרטור sizeof מחזיר תמיד ערך מטיפוס size_t, שאותו מדפיסים בעזרת %zu. השורה הראשונה מציגה את גדלי הבלוקים שהוקצו (10 בתים לחמישה short, 24 בתים לשלושה double, ו-9 בתים לתשעה char), בעוד השורה השנייה מודדת את גודל משתני המצביעים עצמם: כל מצביע תופס 8 בתים ב-64 סיביות, בלי תלות בגודל הבלוק. הפלט הורץ ב-MinGW gcc 16 על Windows.
אותו עיקרון חל גם על הקצאת מערך של מבנים: malloc(n * sizeof(struct item)) מקצה n מבנים ברצף, והגישה היא items[i].field.
בדיקת NULL, כשל הקצאה ו-malloc(0)
הקצאה יכולה להיכשל כשאין זיכרון פנוי, ו-malloc מדווחת על כך ב-NULL, ולכן בודקים את התוצאה לפני כל גישה. כדי לדמות כשל מבקשים (size_t)-1: size_t הוא טיפוס ללא סימן, ו--1 הופך אצלו לגודל המקסימלי האפשרי, שאי אפשר לספק.
תרחיש 8: הקצאה שנכשלת
#include <stdio.h>
#include <stdlib.h>
int main(void) {
char *huge = malloc((size_t)-1);
printf("%s\n", huge ? "allocated" : "out of memory");
free(huge); /* free(NULL) is a safe no-op */
return 0;
}out of memoryהבדיקה huge ? היא מה שמגן על התוכנית: כל עוד אין כתיבה או קריאה דרך המצביע הריק, אין קריסה, והקריאה free(NULL) בסוף מוגדרת כפעולה ריקה. gcc 16 מדפיס בזמן הקומפילציה אזהרת -Walloc-size-larger-than= על הגודל הקבוע, כי הוא גדול מהמקסימום האפשרי של אובייקט. האזהרה מוצדקת, אבל התוכנית חוקית ורצה כרגיל.
הפלט הורץ ב-MinGW gcc 16 על Windows.
הקריאה malloc(0) חוקית: התקן מתיר להחזיר NULL או מצביע ייחודי (כך עושה glibc ב-Linux). אסור לקרוא או לכתוב אף בית דרך המצביע שהוחזר, ותוכן הבלוק אינו מובטח להיות אפס. קוד תקין לא מסתמך על אחת משתי התוצאות, ופשוט מעביר אותה ל-free.
calloc: הקצאה מאופסת
טעות נפוצה היא לקרוא calloc(4, 10) כ"ארבעה בתים שמולאו בעשרה". בפועל הפרמטרים הם מספר איברים וגודל איבר, כלומר 40 בתים מאופסים. ההצהרה היא void *calloc(size_t n, size_t size);, ואין בה מקום לערך מילוי.
אפסים בכל בית נקראים כ-0 ב-int, כ-0.0 ב-float וב-double, וכ-NULL במצביע (ב-x86-64 עם gcc). ל-calloc יש יתרון נוסף: היא בודקת אם המכפלה n * size גולשת, ואם כן מחזירה NULL, בעוד שכתיבה ידנית של malloc(n * size) עלולה לבקש בשקט בלוק קטן מהמתוכנן.
תרחיש 9: ספירה וסכום אחרי calloc
#include <stdlib.h>
#include <stdio.h>
int main(void) {
int *nums = calloc(5, sizeof *nums);
if (!nums) {
return 1;
}
nums[0] = 6;
nums[3] = 6;
int active = 0;
int acc = 0;
for (int k = 0; k < 5; k++) {
if (nums[k] != 0) active++;
acc += nums[k];
}
printf("%d %d\n", active, acc);
free(nums);
return 0;
}2 12שלושת התאים שלא נכתבו (nums[1], nums[2], nums[4]) נשארו 0 ומותר לקרוא מהם. אילו ההקצאה הייתה מתבצעת עם malloc, קריאת התאים שלא אותחלו הייתה התנהגות לא מוגדרת. הפלט הורץ ב-MinGW gcc 16 על Windows.
תרחיש 10: רשימה מקושרת עם calloc
#include <stdio.h>
#include <stdlib.h>
struct item {
int weight;
struct item *next;
};
int main(void) {
struct item *n1 = calloc(1, sizeof *n1);
struct item *n2 = calloc(1, sizeof *n2);
struct item *n3 = calloc(1, sizeof *n3);
if (!n1 || !n2 || !n3) return 1;
n1->next = n2;
n2->next = n3; /* n3->next remains NULL */
n1->weight = 5;
n3->weight = 9;
int count = 0, sum = 0;
for (struct item *cur = n1; cur != NULL; cur = cur->next) {
count++;
sum += cur->weight;
}
printf("%d %d\n", count, sum);
free(n3);
free(n2);
free(n1);
return 0;
}3 14בזכות calloc, השדה n2->weight הוא 0 והשדה n3->next הוא NULL. לכן הלולאה עוברת בבטחה על שלוש החוליות ונעצרת בסוף הרשימה. הפלט הורץ ב-MinGW gcc 16 על Windows.
תרחיש 11: calloc של מבנים עם int ו-double
#include <stdio.h>
#include <stdlib.h>
struct entry {
int id;
double score;
};
int main(void) {
struct entry *list = calloc(2, sizeof *list);
if (list == NULL) return 1;
list[0].score = 2.5;
printf("%d %d %.1f %.1f\n", list[0].id, list[1].id, list[0].score, list[1].score + list[0].score);
free(list);
return 0;
}0 0 2.5 2.5calloc(2, sizeof *list) מקצה מערך של שני מבנים, וכל שדותיהם מתאפסים מראש (0 ו-0.0). לכן הסכום list[1].score + list[0].score הוא 0.0 + 2.5. הפלט הורץ ב-MinGW gcc 16 על Windows.
פונקציה שמקצה בשביל הקורא
בלוק ב-heap אינו שייך למסגרת המחסנית של הפונקציה שיצרה אותו, ולכן הוא נשאר קיים גם לאחר שהיא חוזרת. פונקציה יכולה להקצות בלוק ולהחזיר את כתובתו, והפונקציה הקוראת מקבלת עליו אחריות וצריכה לשחרר אותו עם free.
כשמזמנים את אותה פונקציית הקצאה כמה פעמים ברצף בלי לשחרר ביניהן, כל זימון מייצר בלוק עצמאי בכתובת שונה ב-heap.
תרחיש 12: שני בלוקים משתי קריאות
#include <stdio.h>
#include <stdlib.h>
int *alloc_pair(int first, int second) {
int *buf = malloc(2 * sizeof *buf);
if (buf == NULL) return NULL;
buf[0] = first;
buf[1] = second;
return buf; /* heap block outlives alloc_pair */
}
int main(void) {
int *pairA = alloc_pair(10, 20);
int *pairB = alloc_pair(30, 40);
if (!pairA || !pairB) return 1;
printf("%d %d\n", pairA[0] + pairB[1], pairA != pairB);
free(pairA);
free(pairB);
return 0;
}50 1המשתנה המקומי buf נעלם בסיום alloc_pair, אך הבלוק עצמו נותר ב-heap. שתי הקריאות החזירו שתי כתובות נפרדות, ולכן main משחררת את שתיהן. הפלט הורץ ב-MinGW gcc 16 על Windows.
אם אחרי קריאה לפונקציה המצביע אצל הקורא נשאר NULL, כנראה שהפונקציה קיבלה עותק שלו: ב-C כל הארגומנטים עוברים לפי ערך (by value). int * מעתיק רק את המצביע, ולכן השמה לפרמטר נשארת מקומית; כדי לעדכן את המצביע של הקורא מעבירים את הכתובת שלו, כלומר int **.
תרחיש 13: העברת כתובת של מצביע מול העברת מצביע
#include <stdio.h>
#include <stdlib.h>
void init_ok(int **target, int value) {
*target = malloc(sizeof **target); /* updates caller's pointer */
if (*target != NULL) **target = value;
}
void init_bad(int *target, int value) {
target = malloc(sizeof *target); /* updates local copy only */
if (target != NULL) *target = value;
free(target); /* prevent leak in demo */
}
int main(void) {
int *ok = NULL;
int *bad = NULL;
init_ok(&ok, 14);
init_bad(bad, 14);
printf("%d %d\n", ok != NULL, bad != NULL);
if (ok) printf("%d\n", *ok);
free(ok);
return 0;
}1 0
14ב-init_ok, הכתיבה *target = malloc(...) משנה ישירות את ok שב-main. לעומת זאת init_bad שינתה רק את העותק המקומי שלה, ולכן bad נותר NULL (ובלי ה-free שבסוף init_bad, הבלוק היה דולף). הפלט הורץ ב-MinGW gcc 16 על Windows.
malloc ומחזירה אותו בלי לכתוב אליו, ו-main מדפיסה תא ממנו, אין תשובה מספרית ודאית אחת. הקוד מתקמפל ואינו נעצר מעצמו, אבל מה שנקרא הוא תוכן לא מאותחל (UB), שיכול להשתנות בין הרצות ובין מהדרים.טעויות נפוצות
malloc(4)מקצה מערך של ארבעה מספרים שלמים (int). הפרמטר הוא מספר בתים:4בתים מספיקים ל-intאחד בלבד, ולארבעה צריך4 * sizeof(int)(16 בתים).- גם
mallocוגםcallocמאפסות את הזיכרון שהוקצה. רקcallocמאפסת את הבלוק. בלוק מ-mallocמכיל תוכן לא מאותחל. - הקריאה
calloc(4, 10)מבקשת לאפס 4 בתים לערך 10. אין בה ערך מילוי: 4 הוא מספר האיברים ו-10 הוא הגודל של כל איבר, והבלוק של 40 בתים כולו אפס. - בלוק שהוקצה בתוך פונקציית עזר משתחרר אוטומטית כשהפונקציה מסתיימת. בלוק ב-
heapממשיך לחיות עדfreeאו סיום התהליך. - פונקציה שמקבלת
int *pיכולה להציב בו כתובת מ-mallocעבור הקורא. המצביע עובר לפי ערך. כדי לשנות את המצביע של הקורא נדרשint **.
בדקו את עצמכם
כמה בתים מקצה calloc(3, sizeof(double)), ומה הערך בתא הראשון אם לא כתבו אליו?
24 בתים (3 * 8), והערך בתא הראשון הוא 0.0.
מוגדרת פונקציה void setup(int *p) { p = malloc(sizeof *p); } ונקראת עם int *x = NULL; setup(x);. מה ערכו של x אחרי הקריאה?
NULL. הפונקציה שינתה רק את העותק המקומי של p, והבלוק שהוקצה בתוכה דלף.
realloc: שינוי גודל של בלוק
הגדלת בלוק
כלל אחד מסביר את realloc בהגדלה ובהקטנה: מהבלוק הישן נשמרים הבתים הראשונים, כמספר הקטן מבין הגודל הישן לחדש, ושום דבר מעבר לזה אינו מובטח. ההצהרה היא void *realloc(void *p, size_t new_size);, והיא מחזירה את הכתובת של הבלוק בגודלו החדש.
הכתובת המוחזרת לא חייבת להיות הישנה. לפעמים יש מקום להרחיב את הבלוק במקומו, ולפעמים מוקצה בלוק חדש, התוכן מועתק אליו והבלוק הישן משוחרר, ולכן אחרי הצלחה משתמשים רק במצביע המוחזר.
בהגדלה, הבתים שנוספו אינם מאופסים ואינם מאותחלים. זה נכון גם כשהבלוק המקורי הגיע מ-calloc, כי רק הוא עצמו הגיע מאופס ולא ההרחבה שלו.
תרחיש 14: הגדלה שומרת את התוכן
#include <stdlib.h>
#include <stdio.h>
int main(void) {
int *slots = malloc(3 * sizeof *slots);
if (!slots) {
return 1;
}
slots[0] = 11;
slots[1] = 22;
slots[2] = 33;
int *grown = realloc(slots, 5 * sizeof *slots);
if (!grown) {
free(slots);
return 1;
}
slots = grown;
slots[4] = 55;
printf("%d %d %d\n", slots[0], slots[2], slots[4]);
free(slots);
return 0;
}11 33 55שלושת האיברים הראשונים (11, 22, 33) נשמרו, והתאים החדשים באינדקסים 3 ו-4 התחילו לא מאותחלים. הקוד כתב 55 אל slots[4] לפני ההדפסה ולא נגע ב-slots[3]. הפלט הורץ ב-MinGW gcc 16 על Windows.
תרחיש 15: שתי הגדלות ברצף
#include <stdio.h>
#include <stdlib.h>
int main(void) {
int *seq = malloc(2 * sizeof *seq);
if (seq == NULL) return 1;
seq[0] = 4;
seq[1] = 8;
int *step = realloc(seq, 4 * sizeof *seq);
if (step == NULL) {
free(seq);
return 1;
}
seq = step;
seq[2] = 16;
seq[3] = 32;
step = realloc(seq, 6 * sizeof *seq);
if (step == NULL) {
free(seq);
return 1;
}
seq = step;
seq[4] = 64;
printf("%d %d %d %d\n", seq[0], seq[1] + seq[2], seq[3], seq[4]);
free(seq);
return 0;
}4 24 32 64לפני כל הגדלה נקלט הערך המוחזר למצביע עזר step, ורק אחרי בדיקה מציבים אותו ב-seq. שני האיברים הראשונים נשמרו בשתי ההגדלות, ו-seq[2], seq[3] ו-seq[4] נכתבו לפני שנקראו, לכן אין כאן קריאה של ערך לא מאותחל. הפלט הורץ ב-MinGW gcc 16 על Windows.
הקטנת בלוק
בהקטנה אותו כלל פועל מהכיוון ההפוך: הבלוק נשאר באותה התחלה והוא פשוט קצר יותר. התאים הראשונים שומרים על הערכים שלהם והזנב נחתך, בלי להעתיק אותו להתחלה ובלי לאפס שום תא.
כל פנייה מעבר לגבול החדש, למשל items[3] בבלוק בן שלושה תאים, היא התנהגות לא מוגדרת. שום בדיקה לא נעשית בזמן ריצה, ובזמן הקומפילציה גודלו העדכני של בלוק דינמי אינו ידוע למהדר, ולכן קוד כזה מתקמפל ורץ בלי הבטחה לתוצאה.
תרחיש 16: סכום אחרי הקטנה
#include <stdlib.h>
#include <stdio.h>
int main(void) {
int *items = malloc(5 * sizeof *items);
if (!items) {
return 1;
}
for (int idx = 0; idx < 5; idx++) {
items[idx] = (idx + 1) * 10;
}
int *shrunk = realloc(items, 3 * sizeof *items);
if (!shrunk) {
free(items);
return 1;
}
items = shrunk;
int acc = 0;
for (int idx = 0; idx < 3; idx++) {
acc += items[idx];
}
printf("%d\n", acc);
free(items);
return 0;
}60הבלוק הכיל תחילה 10, 20, 30, 40, 50, ואחרי ההקטנה לשלושה איברים נותרו 10, 20, 30 שסכומם 60. קריאה של items[3] או items[4] לאחר ההקטנה הייתה חורגת מגבולות הבלוק החדש. הפלט הורץ ב-MinGW gcc 16 על Windows.
realloc עם NULL, וכשל של realloc
נתחיל מהשורה p = realloc(p, n);, שנראית תמימה. כש-realloc נכשלת היא מחזירה NULL אך משאירה את הבלוק הישן שלם, ולכן ההשמה דורסת את המצביע היחיד אליו ומשאירה בלוק יתום, כלומר דליפה.
הפתרון הוא מצביע עזר זמני: int *tmp = realloc(p, n);, בדיקה ש-tmp שונה מ-NULL, ורק אחריה p = tmp;. בכשל p עדיין מחזיק את הבלוק עם כל תוכנו, ואפשר להמשיך לעבוד איתו או לשחרר אותו כסדרו.
שני מקרי קצה נוספים:
realloc(NULL, n): שקולה בדיוק ל-malloc(n)ומחזירה בלוק חדש בןnבתים לא מאותחלים.realloc(p, 0): התוצאה תלויה בספרייה (ב-glibcהבלוק משוחרר ומוחזרNULL), ולכן אסור להשתמש בה במקוםfree.
תרחיש 17: realloc כמו malloc, ו-realloc שנכשלת
#include <stdio.h>
#include <stdlib.h>
int main(void) {
int *p = realloc(NULL, 2 * sizeof *p); /* behaves like malloc */
if (p == NULL) return 1;
p[0] = 15;
p[1] = 25;
int *tmp = realloc(p, (size_t)-1); /* impossible allocation size */
printf("%d %d\n", tmp == NULL, p[0] + p[1]);
free(p); /* old block remains valid */
return 0;
}1 40הקריאה הראשונה הצליחה להקצות שני מספרים למרות שקיבלה NULL. השנייה נכשלה והחזירה NULL ל-tmp, אבל הבלוק של p נשאר תקף עם 15 ו-25, ולכן הודפס הסכום 40 ו-free(p) עבר בשלום.
בקומפילציה gcc 16 מזהיר על הגודל הבלתי אפשרי (-Walloc-size-larger-than=), ועם -Wall גם על שימוש ב-p אחרי realloc (-Wuse-after-free=). האזהרה השנייה צפויה, כי המהדר אינו יודע שהקריאה תיכשל ולכן מניח שהבלוק אולי שוחרר. כאן הקוד חוקי בזכות הכשל.
הפלט הורץ ב-MinGW gcc 16 על Windows.
טעויות נפוצות
- אם הבלוק המקורי נוצר ב-
calloc, ההרחבה שלו ב-reallocנשארת מאופסת. רק הבלוק המקורי הגיע מאופס. התאים שנוספו ב-reallocאינם מאותחלים לעולם. - אחרי הקטנה ב-
reallocנשארים האיברים האחרונים, או שכל התוכן הישן נמחק. הבלוק שומר את ההתחלה שלו עד הגודל החדש, והסוף הוא שנחתך. - הקריאה
realloc(NULL, n)אינה חוקית ועלולה לקרוס. היא חוקית לגמרי ועושה בדיוק מה ש-malloc(n)עושה. - כש-
reallocנכשלת הבלוק הישן כבר שוחרר, ולכן אין צורך לשמור עליו. בכשל הבלוק הישן נשאר חי ותקין. אם דרסתם אתpב-NULL, איבדתם את הכתובת שלו והוא דולף. - אחרי
reallocמוצלחת אפשר להשתמש גם במצביע הישן וגם בחדש. אם הבלוק עבר לכתובת אחרת, הישנה כבר שוחררה והשימוש בה פגום.
בדקו את עצמכם
בלוק מכיל את המספרים 5 10 15 20, ומקטינים אותו ל-2 * sizeof(int). מה סכום האיברים שנותרו תקינים?
15. נותרו רק שני האיברים הראשונים: 5 ו-10.
מדוע עדיף לכתוב int *tmp = realloc(p, sz); במקום p = realloc(p, sz);?
מפני שאם realloc תיכשל ותחזיר NULL, ההשמה הישירה תדרוס את p ותגרום לאיבוד הכתובת היחידה של הבלוק הישן (דליפה).
free: מה מותר ומה היא עושה
מה free משאירה אחריה
רבים כותבים free(note); ומניחים שהמשתנה note כבר שווה NULL. אבל החתימה void free(void *p); מקבלת עותק של הכתובת, ולכן לפונקציה אין שום דרך להגיע למשתנה שלכם ולשנות אותו.
| ציפייה | מה קורה בפועל |
|---|---|
| המצביע מתאפס | לא. הערך שבמשתנה נשאר בדיוק כפי שהיה, וממנו בא השם dangling pointer (מצביע תלוי). |
| free מדווחת על כישלון | לא. היא מחזירה void, ואין ערך שאפשר לבדוק. |
| הבתים שבבלוק נמחקים | לא. free אינה מאפסת את התוכן, אבל הבלוק כבר אינו שלכם. |
| free יודעת כמה מצביעים עוד מחזיקים את הכתובת | לא. היא אינה סופרת הפניות, ומשחררת את הבלוק בכל מקרה. |
| אפשר להחזיר למקצה חלק מבלוק | לא. היא מחזירה בלוק שלם שהגיע מ-malloc, calloc או realloc. |
| free(NULL) מסוכנת | לא. לפי התקן היא חוקית ושקטה: אין קריסה ואין אזהרה. |
תרחיש 18: עוזר ששחרר ואיפס, והקורא נשאר עם כתובת ישנה
#include <stdio.h>
#include <stdlib.h>
/* a helper that frees its argument and clears its own copy */
static void drop(char *s) {
free(s);
s = NULL;
}
int main(void) {
char *note = malloc(24);
if (note == NULL) return 1;
char *view = note;
drop(note);
printf("after drop: note is NULL? %d\n", note == NULL);
note = NULL;
free(note); /* free(NULL): a defined no-op */
printf("after reset: note %d, view %d\n", note == NULL, view == NULL);
return 0;
}after drop: note is NULL? 0
after reset: note 1, view 0השורה הראשונה מדפיסה 0: הפונקציה drop אפסה רק את הפרמטר שלה, שהוא עותק, ולכן note של main נשאר עם הכתובת. אחרי שאיפסנו אותו בעצמנו, הקריאה free(note) היא free(NULL) ולא מזיקה.
בשורה השנייה view עדיין אינו NULL: הוא עותק אחר של אותה כתובת, ואיש לא איפס אותו. אילו הוספנו free(view); זה היה שחרור כפול של בלוק שכבר חזר למקצה.
כדי לראות מה ההרגל נותן, ציירו שני חיצים, p ו-q, שמצביעים לאותה תיבה. אחרי free(p); p = NULL; נמחק רק החץ של p: קריאה נוספת ל-free(p) אינה עושה כלום, אבל free(q) עדיין פוגעת בתיבה שכבר שוחררה. לכן איפוס אחרי שחרור מגן על שם אחד בלבד, ועותקים אחרים של הכתובת צריך לאפס או לעקוב אחריהם בנפרד.
p על פני free(p); ואחריה if (p != NULL) free(p);. בין שתי השורות הערך לא זז, ולכן התנאי מתקיים והשחרור חוזר. רק הצבת NULL ביניהן הייתה מכבה אותו.כתובת שלא הגיעה מהמקצה
השאלה אם מותר לשחרר מצביע נענית לפי מקור הכתובת, ולא לפי הטיפוס שלו: int * יכול להחזיק כתובת מ-malloc, והוא יכול להחזיק כתובת של משתנה מקומי, ורק הראשונה חוקית. הקריאה חוקית רק עם NULL, או עם כתובת שקיבלתם מ-malloc, מ-calloc או מ-realloc ושעדיין לא החזרתם.
| מקור הכתובת | דוגמה | למה אסור |
|---|---|---|
| משתנה מקומי | int v; free(&v); | הוא יושב במסגרת המחסנית, והמקצה לא נתן אותו. |
| מערך מקומי | char buf[16]; free(buf); | גם הוא במחסנית. |
| ליטרל, גלובלי או static | char *s = "text"; free(s); | הכתובת נמצאת באזור הנתונים או באזור הקריאה בלבד. |
| אמצע בלוק | free(p + 1); | המקצה מזהה בלוק לפי הכתובת שבה הוא מתחיל. |
| המשתנה עצמו | free(&p); | זו כתובת של המצביע, ולא הכתובת שנמצאת בתוכו. |
מה קורה כשמעבירים ל-free כתובת כזו? יש שלוש תוצאות אפשריות, ואין התחייבות לאף אחת מהן: התהליך נעצר עם הודעה של המקצה (ב-glibc זה הנפוץ), מבני הניהול של ה-heap נפגעים בלי שום סימן, או שהריצה נמשכת כאילו דבר לא קרה. כל אלה הם התנהגות לא מוגדרת.
ולמה המהדר שותק? כל מצביע לנתון מומר מעצמו ל-void *, והמהדר אינו עוקב אחרי המקום שממנו באה הכתובת, ולכן הקוד מתקמפל; לכל היותר gcc מזהיר כשהבעיה בולטת. וגם free עצמה אינה בודקת ודולגת על כתובת זרה.
שתי טעויות הבנה שכיחות. הראשונה: free אינה מפנה מחסנית, כי מסגרת מתפנה לבד ברגע שהפונקציה חוזרת. השנייה: המחסנית אינה לקריאה בלבד, ואפשר לכתוב אליה; הכתובת נפסלת רק משום שהיא לא באה מהמקצה.
תרחיש 19: הסמן שהתקדם לפני השחרור
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main(void) {
char *start = malloc(16);
if (start == NULL) return 1;
strcpy(start, "alpha beta");
char *cursor = start;
while (*cursor != ' ') {
cursor++; /* walks forward inside the block */
}
printf("%td %s\n", cursor - start, cursor + 1);
free(start); /* the original address, not cursor */
return 0;
}5 betaהלולאה מקדמת את cursor חמישה בתים לתוך הבלוק, עד הרווח, וההדפסה מראה את המרחק ואת המילה שאחריו. free(start) מחזירה את הכתובת שבה הבלוק התחיל.
אילו כתבנו free(cursor); זו הייתה כתובת באמצע בלוק, כלומר התנהגות לא מוגדרת. לכן שומרים את כתובת ההתחלה לפני שמזיזים מצביע בתוך בלוק.
char *name = malloc(32); name = fallback; (כש-fallback הוא מערך גלובלי) הקריאה free(name) משחררת כתובת שלא מהמקצה, ו-32 הבתים שהוקצו נותרו בלי מצביע. אלו שתי תקלות נפרדות, ולא שחרור כפול, כי ההשמה לא שחררה דבר.כמה פעמים קוראים ל-free
כשבודקים כמה קריאות ל-free נדרשות, סופרים בלוקים ולא מצביעים. כל malloc או calloc מוצלחים, וגם realloc(NULL, n), פותחים בלוק חדש וקוראים ל-free אחת; realloc על בלוק קיים רק מחליפה אותו, ולכן אינה מוסיפה בלוק.
תרחיש 20: ארגז עם שני בלוקים פנימיים והגדלה באמצע
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
struct crate {
char *label;
int *qty;
int n;
};
int main(void) {
struct crate *c = malloc(sizeof *c); /* block 1 */
if (c == NULL) return 1;
c->label = malloc(8); /* block 2 */
c->qty = calloc(2, sizeof *c->qty); /* block 3 */
if (c->label == NULL || c->qty == NULL) return 1;
strcpy(c->label, "bolts");
c->qty[0] = 5;
c->qty[1] = 7;
int *wider = realloc(c->qty, 4 * sizeof *wider); /* replaces block 3 */
if (wider == NULL) return 1;
c->qty = wider;
c->qty[2] = 1;
c->qty[3] = 1;
c->n = 4;
int sum = 0;
for (int k = 0; k < c->n; k++) sum += c->qty[k];
printf("%s %d\n", c->label, sum);
free(c->label);
free(c->qty);
free(c);
return 0;
}bolts 14יש שלושה בלוקים: המבנה, המחרוזת label ומערך הכמויות. ה-realloc החליפה את הבלוק השלישי בגדול יותר, כך שהספירה נשארה שלושה, והסכום הוא 5 + 7 + 1 + 1, כלומר 14.
לכן נדרשות שלוש קריאות: שתיים לבלוקים הפנימיים ובסוף אחת למבנה. free(c) לבדה הייתה משאירה את שני הפנימיים בלי מצביע.
ציירו את התיבה החיצונית ובתוכה שדה עם חץ החוצה. free של התיבה החיצונית אינה נוגעת בחץ הזה ואינה נוגעת בתיבה שאליה הוא מגיע. ואם החיצונית כבר נמחקה, אין לכם איפה לקרוא את החץ, כי הוא היה בתוכה.
לכן במבנה מקונן משחררים מבפנים החוצה: קודם הבלוקים שהכתובות שלהם שמורות בשדות, ורק אחריהם הבלוק שמחזיק את השדות.
בטבלת שורות (int **t, עם הקצאה נפרדת לכל t[r]) יש שתי טעויות אפשריות. free(t) לבדה משאירה את כל השורות בלי מצביע, ו-free(t[0]) מחזירה שורה אחת בלבד. כל שורה היא הקצאה עצמאית, ואין בלוק אחד שמכיל את כולן.
תרחיש 21: העברת בעלות על בלוק פנימי
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
struct crate {
char *label;
int *qty;
};
/* hands the label to the caller and forgets it */
static char *detach_label(struct crate *c) {
char *t = c->label;
c->label = NULL;
return t;
}
int main(void) {
struct crate *c = malloc(sizeof *c);
if (c == NULL) return 1;
c->label = malloc(8);
c->qty = malloc(sizeof *c->qty);
if (c->label == NULL || c->qty == NULL) return 1;
strcpy(c->label, "nuts");
*c->qty = 40;
char *kept = detach_label(c);
free(c->qty);
free(c); /* frees the struct block only */
printf("%s\n", kept); /* the label block is still alive */
free(kept);
return 0;
}nutsdetach_label מוציאה את הכתובת מהשדה ומשאירה בו NULL, כך שהמחרוזת נשארת בידי הקורא. free(c) משחררת רק את בלוק המבנה, ולכן ההדפסה של kept חוקית.
אילו הכתובת הייתה שמורה רק בתוך המבנה, קריאה של השדה אחרי free(c) הייתה קריאה מבלוק משוחרר. זו הסיבה שהוצאנו אותה קודם.
טעויות נפוצות
- אחרי
free(p)המשתנהpשווהNULL. הכתובת הועברה בעותק, והערך שב-pנשאר כפי שהיה עד שאתם משנים אותו בהשמה. free(NULL)מפילה את התוכנית, או שהיא התנהגות לא מוגדרת. התקן קובע שהיא אינה עושה דבר, ולכן היא בטוחה.- כשמשחררים כתובת לא תקינה
freeמחזירה קוד שגיאה. היא מחזירהvoid, ואין לה ערך שאפשר לבדוק. freeמזהה כתובת שלא הוקצתה ופשוט מדלגת עליה. אין התנהגות כזו: התוצאה היא התנהגות לא מוגדרת, מעצירה ועד השחתת ה-heap או המשך כאילו דבר לא קרה.- שחרור של מערך מקומי נכשל כבר בקומפילציה. הקוד מתקמפל בגלל ההמרה ל-
void *, והתקלה היא בזמן ריצה. freeעל מבנה משחררת גם את מה שהשדות שלו מצביעים אליו. היא משחררת בלוק אחד בלבד, ולכן הפנימיים משוחררים קודם.- על מערך שהוקצה בקריאה אחת צריך
freeלכל איבר. בלוק אחד דורשfreeאחת, ו-freeעל איבר באמצע היא כתובת שאינה תחילת בלוק.
בדקו את עצמכם
char *a = malloc(4); char *b = realloc(a, 40); (הצליחה) ואחריה char *c = malloc(4);. על אילו משתנים קוראים ל-free, וכמה פעמים?
פעמיים: על b ועל c. a ו-b הם אותו בלוק (שאולי הוזז), ולכן free(a) על הכתובת הישנה אינה חוקית.
האם char *s = "hi"; free(s); מתקמפל, ומה קורה בריצה?
הוא מתקמפל, ובריצה זו התנהגות לא מוגדרת, כי הכתובת היא של ליטרל ולא של בלוק מהמקצה.
ארבעת הבאגים הקלאסיים
איך מזהים כל באג, ומה זה לא
בשאלות מעקב על חצים ותיבות מזהים את הבאג לפי ארבע שאלות על הציור:
- נשארה תיבה חיה שאין אליה אף חץ? זו דליפת זיכרון (
memory leak). - קוראים או כותבים דרך חץ אל תיבה שכבר נמחקה? זה שימוש אחרי שחרור (
use after free). freeנקראת פעם שנייה על תיבה שנמחקה? זה שחרור כפול (double free).- האינדקס חורג מתאי התיבה, למטה מ-0 או מ-
nומעלה? זו חריגה מגבולות (buffer overflow).
| באג | מה קורה בריצה | הטעות בשורה אחת |
|---|---|---|
| דליפה | אין קריסה ואין התנהגות לא מוגדרת; הזיכרון תפוס עד סוף התהליך. | הכתובת של בלוק חי אבדה. |
| שימוש אחרי שחרור | התנהגות לא מוגדרת. | הכתובת נשארה במצביע ונעשה בה שימוש אחרי free. |
| שחרור כפול | התנהגות לא מוגדרת. | בלוק אחד קיבל שתי קריאות free. |
| חריגה מגבולות | התנהגות לא מוגדרת. | הגישה יצאה אל מחוץ לבלוק. |
מסיח נוסף הוא פיצול זיכרון (fragmentation). דמיינו heap שנשארו בו, אחרי אלפי הקצאות ושחרורים, עשרות חורים קטנים: סכומם גדול, אבל בקשה לבלוק גדול אחד ורציף לא תמצא מקום.
פיצול הוא מצב שמצטבר במקצה לאורך זמן, ולכן אי אפשר לסמן שורה אחת כאחראית עליו. שאלה שמתמקדת בבלוק אחד, בשחרור שלו או בכתיבה אליו, אינה מחפשת פיצול.
חזרה לתוכן הענייניםדליפת זיכרון
ציירו תיבה שאין אליה אף חץ: זו דליפה. המקצה עדיין רואה אותה כתפוסה, ואי אפשר להחזיר אותה, כי free דורשת כתובת והכתובת אבדה.
- התוכנית ממשיכה לרוץ כרגיל, ואין התנהגות לא מוגדרת.
- הזיכרון נשאר תפוס כל חיי התהליך, ובסופו מערכת ההפעלה מחזירה אותו.
- הנזק הממשי הוא בתהליך ארוך חיים, כמו שירות, שבו התפוסה רק עולה עם הזמן.
תרחיש 22: ספירת בלוקים חיים
#include <stdio.h>
#include <stdlib.h>
static int live = 0; /* blocks allocated and not yet freed */
static void *grab(size_t n) {
void *p = malloc(n);
if (p != NULL) live++;
return p;
}
static void release(void *p) {
if (p != NULL) {
free(p);
live--;
}
}
static void note_event(int code) {
char *line = grab(40);
if (line == NULL) return;
sprintf(line, "event %d", code);
if (code % 2 == 0) {
release(line); /* only even codes reach this line */
}
} /* 'line' disappears, its block does not */
int main(void) {
for (int code = 1; code <= 5; code++) {
note_event(code);
}
printf("live blocks: %d, bytes: %d\n", live, live * 40);
return 0;
}live blocks: 3, bytes: 120הפונקציה release נקראת רק בקודים הזוגיים, ולכן הקודים 1, 3 ו-5 משאירים בלוק של 40 בתים כל אחד: שלושה בלוקים, 120 בתים. המצביע line (8 בתים במחסנית) נעלם בסוף הפונקציה כרגיל, והבלוק לא.
valgrind הוא כלי שמריץ את התוכנית ועוקב אחרי כל ההקצאות. בסוף הריצה הוא מדווח על בלוקים שאף מצביע אינו מחזיק בהם תחת definitely lost, וכאן היה מדווח על 120 בתים בשלושה בלוקים.
איך נשארת תיבה בלי חץ? שלוש דרכים נפוצות, וכל אחת עם שורת דוגמה:
- יציאה באמצע (early return):
if (err) return -1;בנתיב שגיאה עוזבת את הפונקציה ומדלגת על כל קריאות ה-freeשהוצבו אחריה. - מצביע מקומי שנעלם:
char *tmp = malloc(32);שאינו משוחרר ואינו מוחזר.tmpנעלם בסוף הפונקציה, והבלוק נשאר. - דריסה של המצביע היחיד:
p = malloc(8);ואחריה שובp = malloc(8);, אוp = NULL;, אוp = other;, לפני שהבלוק שוחרר.
שימו לב למה שהשמה אינה עושה: היא מפנה את המשתנה למקום אחר, וזהו. הבלוק שבקצה הקודם נשאר שלם ויתום, ושתי הקצאות ברצף בלי free ביניהן מניבות שני בלוקים נפרדים.
אותו חישוב בגדול: פונקציה שמקצה 128 * sizeof(double), כלומר 1,024 בתים, ונקראת 30,000 פעם בלי free משאירה 30,720,000 בתים, כ-30 MB. זו דליפה ב-heap ולא גלישת מחסנית, כי malloc אינה ממחזרת בלוק שלא שוחרר.
תרחיש 23: כשל באמצע לולאת הקצאות
#include <stdio.h>
#include <stdlib.h>
#define SLOTS 4
static int live = 0;
static void *grab(size_t n) {
void *p = malloc(n);
if (p != NULL) live++;
return p;
}
static void release(void *p) {
if (p != NULL) {
free(p);
live--;
}
}
/* fail_at simulates an allocation failure at that slot index */
static int fill_slots(int fail_at) {
char *slot[SLOTS] = { NULL };
for (int k = 0; k < SLOTS; k++) {
slot[k] = (k == fail_at) ? NULL : grab(16);
if (slot[k] == NULL) {
for (int j = 0; j < k; j++) {
release(slot[j]); /* only the slots that exist */
}
return k;
}
}
for (int k = 0; k < SLOTS; k++) {
release(slot[k]);
}
return SLOTS;
}
int main(void) {
int a = fill_slots(2);
int b = fill_slots(9);
printf("%d %d live=%d\n", a, b, live);
return 0;
}2 4 live=0הפרמטר fail_at מדמה כשל הקצאה: ב-fill_slots(2) נוצרים תאים 0 ו-1, התא 2 מקבל NULL, ותא 3 לא נוצר כלל. לפני היציאה משחררים רק את התאים שקיימים, כלומר j < k.
הכלל לכל יציאה מהפונקציה: להחזיר את כל מה שכבר נלקח עד אותו רגע, ולכן בסוף live=0. אילו דילגנו על לולאת הניקוי, היה הסופר מראה live=2 גם כשהנתיב הרגיל נקי.
free אחת בסוף חייו. לעומת זאת, פונקציה שמחזירה בלוק לקורא ומשחררת אותו לפני כן משאירה לקורא כתובת תלויה, וזה כבר באג אחר.שימוש אחרי שחרור
קוראים ערך דרך מצביע לבלוק ששוחרר. מה מתקבל? זה תלוי במה שקרה לאותו מקום מאז, ואי אפשר לצפות:
- הערך הישן, כי
freeאינה מוחקת את התוכן, והכול נראה תקין. - ערך של מישהו אחר, אם
mallocמאוחרת כבר הקצתה את אותו מקום. - קריסה.
אין בתקן מילוי בתבנית קבועה ואין מנגנון שתופס גישה כזו, ולכן התוכנית נראית לעיתים תקינה, וזה בדיוק מה שמסוכן בבאג הזה. שמו הוא שימוש אחרי שחרור (use after free): כל קריאה או כתיבה דרך מצביע לבלוק ששוחרר, והיא התנהגות לא מוגדרת. אין הבדל אם זה המצביע שנשלח ל-free או עותק שנוצר לפניו, ואם השחרור נעשה בפונקציה אחרת.
איך מבדילים אותו מבאגים קרובים? זו לא דליפה, כי הבלוק כן הוחזר. וזו לא חריגה מגבולות, כי אפילו אינדקס שנמצא בתוך הטווח המקורי פסול אחרי השחרור.
תרחיש 24: מחיקת רשימה מקושרת
#include <stdio.h>
#include <stdlib.h>
struct cell {
int val;
struct cell *next;
};
int main(void) {
struct cell *head = NULL;
for (int v = 3; v >= 1; v--) {
struct cell *c = malloc(sizeof *c);
if (c == NULL) return 1;
c->val = v * 10;
c->next = head;
head = c;
}
int sum = 0;
while (head != NULL) {
struct cell *after = head->next; /* read the field BEFORE the free */
sum += head->val;
free(head);
head = after;
}
printf("%d\n", sum);
return 0;
}60הלולאה שומרת את head->next לפני שהיא משחררת את הצומת. הכתיבה הנפוצה והשגויה היא free(head); head = head->next;, שקוראת שדה מתוך צומת ששוחרר זה עתה: שימוש אחרי שחרור.
בגרסה הנכונה הסכום הוא 10 + 20 + 30, כלומר 60, ושלושת הצמתים משוחררים.
שימו לב להבדל בין ערך לגישה: if (copy != NULL) על כתובת משוחררת רק משווה מספר, ואינו פונה לזיכרון. מה שאסור הוא *copy או copy[i].
שחרור כפול
לכל בלוק מגיעה free אחת בדיוק במהלך חייו. קריאה נוספת על אותה כתובת, אחרי שהבלוק כבר חזר למקצה, היא שחרור כפול (double free) והתנהגות לא מוגדרת.
- העתקת מצביע (
q = p) יוצרת שני שמות לבלוק אחד, וכל שם מועבר ל-free. - פונקציית עזר מקבלת מצביע ומשחררת אותו, ואחריה גם הפונקציה שקראה לה מסיימת ב-
freeעל אותו בלוק. - שתי שורות
freeברצף על אותו משתנה, בלי הצבתNULLביניהן.
מה רואים בפועל? ב-glibc לעיתים התוכנית עוצרת עם הודעה בנוסח free(): double free detected, אבל אין בכך ערובה, ובמקרים אחרים מבני הניהול של ה-heap נפגעים בשקט. לכן הכלל הוא free אחת לכל בלוק, ולא לכל מצביע: המקצה אינו סופר הפניות.
תרחיש 25: אילו קריאות הן הבאג
char *a = malloc(8);
char *b = malloc(8);
char *c = a;
free(a); /* call 1 */
free(b); /* call 2 */
a = NULL;
free(c); /* call 3 */
free(a); /* call 4 */קריאה 1 משחררת את הבלוק הראשון, וקריאה 2 משחררת בלוק אחר לגמרי, ולכן שתיהן תקינות. קריאה 3 משחררת שוב את הבלוק הראשון, כי c עדיין מחזיק את כתובתו, ולכן היא שחרור כפול.
קריאה 4 היא free(NULL), כי a אופס, והיא חוקית. רק קריאה אחת מבין הארבע היא באג.
חריגה מגבולות הבלוק
מה משותף ללולאה for (k = 0; k <= n; k++) ולאינדקס שלילי? שניהם נוגעים בתא שמחוץ לטווח 0..n-1 של בלוק בן n איברים. בלולאה זה קורה בחזרה ה-n + 1, באיבר מספר n, ונגיעה כזו היא חריגה מגבולות (heap buffer overflow) והתנהגות לא מוגדרת.
אין מי שיעצור אתכם. בזמן ריצה C לא בודקת אינדקסים, המהדר לא מכיר את הגודל של בלוק שהוקצה בריצה, והבלוק לא מתרחב לפי הצורך. גם מערכת ההפעלה לא תתערב: ההגנה שלה חלה על דפי זיכרון, ולא על הקצה של בלוק בודד.
ציירו שתי תיבות סמוכות בזיכרון, A ו-B. כתיבה אחת מעבר לסוף A נוחתת על B או על נתוני הניהול של המקצה (השחתת heap), ובדרך כלל אין שום סימן. אם תהיה קריסה, היא תבוא מאוחר יותר ובשורה אחרת, ולפעמים הכול ייראה תקין.
| צורת הקוד | מה קורה בפועל | איפה זה חורג |
|---|---|---|
for (k = 0; k <= n; k++) | n + 1 חזרות. | האיבר ה-n, אחרי הסוף. |
int *a = malloc(10); | 10 בתים, ולא 10 איברים: יש מקום לשני int שלמים. | כל אינדקס מ-2 ומעלה. |
malloc(strlen(s)) ואחריה strcpy | אין בית לתו הסיום. | בית אחד אחרי הסוף. |
p[k] על בלוק של n איברי int, כש-k >= n | הכתובת היא p ועוד k * 4 בתים: p[10] נמצא 40 בתים אחרי ההתחלה, ולא 10. | מחוץ לבלוק, שאורכו 4n בתים. |
מצביע ל-p + n, אחד אחרי הסוף, מותר להחזיק ולהשוות אליו, אבל אסור לקרוא או לכתוב דרכו. p + n + 1 כבר התנהגות לא מוגדרת גם בלי גישה. free(p) נשארת תקינה כל עוד p עצמו לא השתנה.
כדי לתפוס את הבאג בבדיקות מריצים את התוכנית תחת valgrind, או מקמפלים עם AddressSanitizer (gcc -fsanitize=address): שניהם מדווחים על הגישה הלא חוקית בזמן הריצה.
תרחיש 26: היסטוגרמה עם בדיקת טווח
#include <stdio.h>
#include <stdlib.h>
int main(void) {
int *bins = calloc(4, sizeof *bins);
if (bins == NULL) return 1;
const char *letters = "abddcabdz";
for (const char *c = letters; *c != '\0'; c++) {
int idx = *c - 'a';
if (idx >= 0 && idx < 4) { /* valid indices are 0..3 only */
bins[idx]++;
}
}
printf("%d %d %d %d\n", bins[0], bins[1], bins[2], bins[3]);
free(bins);
return 0;
}2 2 1 3לבלוק יש ארבעה תאים, ולכן הבדיקה היא idx < 4, ולא <=. האות z נותנת אינדקס 25, והייתה כותבת הרחק מחוץ לבלוק אילולא הבדיקה, ולכן היא מדולגת.
בסוף הבלוק אין "תא אפס" שממתין לקריאה, והאינדקס אינו חוזר להתחלה: כל מה שמעבר לתא האחרון הוא זיכרון של מישהו אחר.
טעויות נפוצות
- כשמצביע מקומי יוצא מהתחום (scope), הבלוק שלו משתחרר איתו. המשתנה שבמחסנית נעלם, אבל הבלוק ב-heap נשאר חי, ואם אין אליו מצביע זו דליפה.
- אם המצביע יצא מהתחום, יש דליפה גם בקוד ששחרר את הבלוק קודם. דליפה היא רק בלוק שנשאר מוקצה בלי מצביע; בלוק ששוחרר בזמן אינו דולף.
mallocשנייה מחזירה את הבלוק הראשון ומשתמשת בו מחדש. כל עוד הראשון לא שוחרר, המקצה נותן בלוק אחר.- שימוש אחרי שחרור תמיד מפיל את התוכנית, או תמיד מדפיס זבל. אין תוצאה מובטחת: אפשר גם לקבל את הערך הישן ללא תקלה.
i <= nקורא איבר נוסף שערכו 0. האיבר הנוסף נמצא מחוץ לבלוק, ואין שם ערך מוגדר.- התוכנית תמיד תיעצר ב-segmentation fault, כי מערכת ההפעלה בודקת כל גישה מול הגודל שהוקצה. היא לא בודקת גבולות של בלוק בודד, אלא רק דפים שלמים.
בדקו את עצמכם
char *s = malloc(20); char *t = malloc(20); s = t; free(s); איזה בלוק דולף, ומה עוד חשוד בקוד?
הבלוק הראשון דולף, כי ההשמה s = t אבדה את כתובתו. free(s) משחררת את הבלוק של t, ולכן כל שימוש ב-t אחר כך הוא שימוש אחרי שחרור, ו-free(t) הייתה שחרור כפול.
int *a = malloc(5 * sizeof *a); ואחריה for (i = 1; i <= 5; i++) a[i] = i;. מה הבעיה?
האינדקסים החוקיים הם 0 עד 4, והלולאה כותבת ל-a[5], מחוץ לבלוק. בנוסף a[0] אף פעם לא נכתב.
char ומחרוזות בזיכרון
sizeof מול strlen ותו הסיום
נתחיל בלהסתכל על מחרוזת כשורת בתים. ההדפסה הבאה עוברת על כל בתי המערך tag, ולא רק על האותיות:
תרחיש 27: שורת הבתים של מחרוזת קצרה
#include <stdio.h>
#include <string.h>
int main(void) {
char tag[] = "net";
for (size_t i = 0; i < sizeof(tag); i++) {
printf("tag[%zu] = %d\n", i, tag[i]);
}
printf("sizeof %zu, strlen %zu\n", sizeof(tag), strlen(tag));
return 0;
}tag[0] = 110
tag[1] = 101
tag[2] = 116
tag[3] = 0
sizeof 4, strlen 3שלוש האותיות הן הערכים 110, 101 ו-116, והבית הרביעי הוא 0: תו הסיום '\0', שמסמן איפה המחרוזת נגמרת. sizeof סופר את כל ארבעת הבתים, ו-strlen עוצרת לפני האפס.
מחרוזת ב-C אינה טיפוס נפרד: היא תווים רצופים שאחריהם בית אחד של 0, והבית הזה שמור במקום משלו. כל אחד משני המדדים קורא דבר אחר:
sizeof(x)נקבע בקומפילציה לפי הטיפוס של המשתנה, בלי להסתכל בתוכן: למערך הוא נותן את מספר הבתים שלו כולו, ולמצביע את גודל המצביע.strlen(s)אינה נקבעת מראש: בזמן ריצה היא עוברת על הבתים החל מ-sועוצרת באפס הראשון, והתוצאה היא מספר הבתים שעברה לפניו.
הגדלים בטבלה ובפלטים בפרק הזה מניחים בנייה של 64 סיביות (למשל gcc על x86-64), שבה מצביע תופס 8 בתים; בבנייה של 32 סיביות הוא תופס 4.
| הצהרה | sizeof | strlen | הסבר |
|---|---|---|---|
char z[] = "kernel"; | 7 | 6 | המערך נבנה לפי שש אותיות ועוד תו סיום. |
char z[32] = "kernel"; | 32 | 6 | גודל המערך הוא מה שהוצהר, לא אורך המחרוזת. |
char *z = malloc(32); ובו "kernel" | 8 | 6 | sizeof מודד את המצביע, ולא את הבלוק שמאחוריו. |
const char *z = "kernel"; | 8 | 6 | גם כאן z הוא מצביע. |
כשבידכם מצביע בלבד, אין מי שיודע כמה בתים הוקצו מאחוריו: sizeof רואה רק את המצביע, ולכן גודל הבלוק חייב להישמר במשתנה נפרד. אותו עיקרון בכל טיפוס: ל-int nums[6] יש sizeof של 24, אבל אחרי int *q = malloc(6 * sizeof *q); הערך sizeof(q) הוא 8, ו-sizeof(*q) הוא 4, גודל איבר בודד.
העתקה של s לבלוק שהוקצה מחייבת strlen(s) + 1 בתים. בלי ה-1, תו הסיום ש-strcpy כותבת נוחת בבית שאחרי הבלוק.
תרחיש 28: כמה בתים דרושים למחרוזת מורכבת
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main(void) {
char *pair = NULL;
const char *key = "mode";
const char *val = "fast";
size_t need = strlen(key) + 1 + strlen(val) + 1; /* '=' and the terminator */
pair = malloc(need);
if (pair == NULL) return 1;
sprintf(pair, "%s=%s", key, val);
printf("%zu %zu %zu %s\n", need, strlen(pair), sizeof(pair), pair);
free(pair);
return 0;
}10 9 8 mode=fastהצורה key=val צריכה את אורך המפתח, בית ל-'=', את אורך הערך, ובית לתו הסיום: 4 + 1 + 4 + 1 = 10. strlen(pair) נותנת 9, ו-sizeof(pair) הוא 8 (בנייה של 64 סיביות), גודל מצביע, ולא 10 שהוקצו.
תרחיש 29: מקום לרשימת מחרוזות נפרדות
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main(void) {
size_t need = 0;
const char *names[] = { "red", "green", "blue", "x" };
for (int w = 0; w < 4; w++) {
need += strlen(names[w]) + 1;
}
char *pool = malloc(need);
if (pool == NULL) return 1;
printf("%zu\n", need);
free(pool);
return 0;
}17ספרו כל מחרוזת בנפרד, אותיותיה ועוד האפס שלה: "red" נותנת 3 + 1 = 4, "green" 5 + 1 = 6, "blue" 4 + 1 = 5, ו-"x" 1 + 1 = 2. הסך הכול 17.
אפשר לאמת גם מהכיוון ההפוך: סכום האותיות הוא 3 + 5 + 4 + 1 = 13, ויש ארבע מחרוזות, ולכן מוסיפים ארבעה אפסים. מספר תווי הסיום שווה למספר המחרוזות, לא ל-1 ולא ל-3.
strcpy, strcat ו-%s: אילו בתים נכתבים
בשאלות מעקב מופיעות שלוש פונקציות מחרוזת, ובשביל לעקוב צריך לדעת בדיוק אילו בתים כל אחת כותבת. נתחיל ב-strcat, כי היא הנפוצה ביותר בטעויות.
תרחיש 30: בתים לפני ואחרי strcat
#include <stdio.h>
#include <string.h>
static void dump(const char *label, const char *b) {
printf("%s:", label);
for (int i = 0; i < 8; i++) printf(" %d", b[i]);
printf("\n");
}
int main(void) {
char b[8];
memset(b, 'x', sizeof b); /* 120 everywhere, so a stray 0 stands out */
strcpy(b, "ab");
dump("after strcpy", b);
strcat(b, "cd");
dump("after strcat", b);
printf("%s %zu\n", b, strlen(b));
return 0;
}after strcpy: 97 98 0 120 120 120 120 120
after strcat: 97 98 99 100 0 120 120 120
abcd 4אחרי strcpy הבתים הם 97, 98 ו-0, והשאר 120 (האות x), כדי שכל אפס יבלוט. strcat מתחילה לכתוב בדיוק במקום שבו עמד תו הסיום של dst: היא דורסת אותו ב-'c', ממשיכה ל-'d', וכותבת תו סיום חדש בבית החמישי.
לכן לא נשאר אפס בין החלקים, ו-%s מדפיסה את שניהם ברצף: abcd.
| פונקציה | מה היא כותבת | מקום שצריך ב-dst |
|---|---|---|
strcpy(dst, src) | את כל תווי src ואת תו הסיום שלו, ואינה מקצה זיכרון. | strlen(src) + 1 |
strcat(dst, src) | מתחילה במקום ה-'\0' של dst, דורסת אותו ב-src וכותבת תו סיום חדש בסוף. | strlen(dst) + strlen(src) + 1 |
sprintf(dst, ...) | טקסט מעוצב כמו printf, ואחריו תו סיום. | אורך הטקסט המעוצב ועוד 1 |
אפשר לתת ל-strcpy וגם ל-strcat מחרוזת קבועה כמקור: פרמטר המקור שלהן מוגדר const char *, והן מבטיחות שלא ישנו אותו, ולכן ההעתקה מליטרל לחוצץ רגיל מתקמפלת. היעד הוא זה שנכתב, ולכן הוא אינו const. בנוסף, %s אינה יודעת אורך: היא קוראת מהכתובת קדימה ועוצרת בבית האפס הראשון, גם אם אחריו יש עוד תווים בחוצץ.
מכאן כלל קריאה: אחרי char r[12] = "Go!"; strcat(r, " now"); מודפס Go! now, כולל הרווח, וזה 7 תווים. הטקסט המקורי לבדו אינו תוצאה אפשרית, כי התו שסימן את סופו נדרס.
- הכלל לספירת בתים הוא מספר האותיות ועוד 1. ל-
"gate"נדרשים 5 בתים, ולכןmalloc(4)כותבת את תו הסיום מחוץ לבלוק. - בבניית מחרוזת תו אחר תו,
q[0] = 'o'; q[1] = 'k'; q[2] = '\0';, צריך 3 בתים לפחות. - אם שורת ה-
'\0'נשכחת,%sממשיכה לקרוא עד שתיתקל באפס כלשהו, אולי רק הרחק אחרי הבלוק.
תרחיש 31: בניית רשימה עם realloc ו-strcat
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main(void) {
char *list = malloc(1);
if (list == NULL) return 1;
list[0] = '\0';
const char *words[] = { "red", "green", "blue" };
for (int k = 0; k < 3; k++) {
size_t need = strlen(list) + strlen(words[k]) + 1 + 1; /* ',' and terminator */
char *grown = realloc(list, need);
if (grown == NULL) {
free(list);
return 1;
}
list = grown;
strcat(list, words[k]);
strcat(list, ",");
}
printf("%s %zu\n", list, strlen(list));
free(list);
return 0;
}red,green,blue, 15בכל סיבוב הגודל הדרוש הוא האורך הנוכחי, אורך המילה, בית לפסיק ובית לתו הסיום. ה-realloc נשמרת במשתנה זמני grown, כדי שבכישלון עדיין אפשר לשחרר את list.
התוצאה red,green,blue, היא 15 תווים: 3 + 1 + 5 + 1 + 4 + 1, ובתוך הבלוק האחרון (16 בתים) נשאר מקום לתו הסיום.
מערך שמותר לשנות מול מצביע לליטרל
שתי שורות שנראות כמעט זהות מייצרות מצב שונה בזיכרון, והשוואה ביניהן מסבירה את כל ההתנהגות:
| הצהרה | מה נוצר | אפשר לשנות תו? | sizeof (64 סיביות) |
|---|---|---|---|
char arr[] = "ocean"; | מערך חדש בן 6 בתים (במחסנית, אם הוא מקומי) עם עותק של התווים. | כן | 6 |
char *p = "ocean"; | מצביע בלבד, אל הליטרל שיושב באזור לקריאה בלבד. | לא: התנהגות לא מוגדרת | 8 |
- הכתיבה
p[0] = 'O';נוגעת בזיכרון שאסור לשנות, והיא התנהגות לא מוגדרת. התוצאות האפשריות: segmentation fault, וזו הנפוצה ביותר, או משהו אחר שהתקן אינו מבטיח. - הקומפילציה מצליחה בלי
const, כי C אינה מחייבת אותו כאן, ולכן הטעות נחשפת רק בהרצה.
אם הליטרל עצמו אינו משתנה, איך מקבלים טקסט שאפשר לערוך? יוצרים אותו בעצמכם: מערך char arr[] = "ocean";, או בלוק שהוקצה ב-malloc ואליו מועתק הטקסט. ההצהרה const char * מוסיפה רשת ביטחון, כי אז הניסיון לשנות תו נעצר כבר בהידור, בהודעה כזו:
#include <stdio.h>
int main(void) {
const char *motto = "ocean";
motto[0] = 'O';
printf("%s\n", motto);
return 0;
}lit.c: In function 'main':
lit.c:5:14: error: assignment of read-only location '*motto'
5 | motto[0] = 'O';
| ^תרחיש 32: האות הגדולה והמערך הפרטי
#include <stdio.h>
int main(void) {
char arr[] = "ocean"; /* a private, writable copy */
const char *lit = "ocean"; /* points at the literal itself */
for (char *c = arr; *c != '\0'; c++) {
*c = *c - 'a' + 'A';
}
printf("array: %s (%zu bytes)\n", arr, sizeof(arr));
printf("literal: %s (%zu bytes)\n", lit, sizeof(lit));
return 0;
}array: OCEAN (6 bytes)
literal: ocean (8 bytes)הלולאה הופכת כל אות במערך לגדולה, ורק arr משתנה: הוא עותק, והליטרל ש-lit מצביע אליו נשאר ocean. המערך תופס 6 בתים (חמש אותיות וסיום), והמצביע 8 בבנייה של 64 סיביות.
טעויות נפוצות
strlenמונה גם את'\0', ו-sizeofשל מערך מחרוזת מתעלם ממנו. ההפך:strlenעוצרת לפני תו הסיום, ו-sizeofשל מערך כולל אותו.sizeof(p)על מצביע מודד את הבלוק ש-mallocנתנה. הוא נותן את גודל המצביע עצמו, 8 בתים ב-64 סיביות.- כדי לשכפל מחרוזת
sמספיק להקצותstrlen(s)בתים. חסר הבית של תו הסיום, ו-strcpyכותבת אחרי הבלוק. strcpyמקצה זיכרון בעצמה, או שאינה כותבת תו סיום. היא לא מקצה, והיא תמיד מעתיקה גם את תו הסיום.- אחרי
strcatנשאר תו סיום בין המחרוזות, ולכן מודפס רק החלק הראשון.strcatדורסת את תו הסיום הישן ומשרשרת, ולכן מודפסים שני החלקים. - כתיבה דרך
char *p = "..."היא חוקית, או שהיא שגיאת קומפילציה. הקוד מתקמפל, והכתיבה בזמן ריצה היא התנהגות לא מוגדרת.
בדקו את עצמכם
מה מדפיסה printf("%zu %zu", sizeof(buf), strlen(buf)); כש-char buf[24] = "router";?
24 6: הגודל המוצהר של המערך, ואורך המחרוזת.
מה מדפיסה char s[16] = "ab"; strcat(s, "cd"); printf("%s %zu", s, strlen(s));, ולמה לא רק ab?
abcd 4. strcat מתחילה לכתוב במקום ה-'\0' ודורסת אותו, ולכן שום אפס לא עוצר את ההדפסה אחרי ab.
כמה בתים צריך להקצות לעותק של "firewall"?
9: שמונה אותיות ותו סיום.
גודל של struct ושל union
יישור וריפוד ב-struct
למה הגודל של מבנה יוצא לפעמים גדול מסכום גדלי השדות? הסיבה היא דרישת היישור (alignment): כתובת שבה יושב ערך חייבת להתחלק במספר קבוע שנקבע לפי הטיפוס. ב-x86-64 עם gcc מספר היישור של טיפוס בסיסי הוא פשוט הגודל שלו: 1 עבור char, 2 עבור short, 4 עבור int ו-float, ו-8 עבור double וכל מצביע.
דוגמה קטנה: ב-struct { char a; int b; } השדה a יושב בהיסט 0. השדה b צריך היסט שמתחלק ב-4, ולכן המהדר משאיר שלושה בתי ריפוד (padding) ומציב אותו בהיסט 4; הסוף בבית 7, והגודל 8.
- ההיסט של השדה הראשון הוא 0, בלי ריפוד לפניו.
- כל שדה אחר מתחיל בהיסט הקטן ביותר שמתחלק ביישור שלו ואינו קטן מסוף השדה הקודם; הפער הוא ריפוד.
- בסוף מעלים את הגודל הכולל עד הכפולה הקרובה של היישור הגדול שנמצא בין השדות, ולכן ייתכן ריפוד גם אחרי השדה האחרון.
המסקנה: גודל המבנה אף פעם אינו קטן מסכום השדות, והוא שווה לו רק כשלא נוצר ריפוד, כמו בשני int. סדר ההצהרה משפיע על התוצאה.
כדי לבדוק היסט בפועל משתמשים ב-offsetof(type, member) שמוגדר ב-<stddef.h>. וההקצאה malloc(sizeof *p) כבר כוללת את הריפוד, ואין צורך להוסיף אותו.
בחישוב ביד מנהלים טבלה עם מונה. לדוגמה, עבור struct { short a; double b; char c; }:
| שדה | יישור | המונה לפני | ממוקם בהיסט | המונה אחרי |
|---|---|---|---|---|
a (short) | 2 | 0 | 0 | 2 |
b (double) | 8 | 2 | 8 | 16 |
c (char) | 1 | 16 | 16 | 17 |
| עיגול סופי | 8 | 17 | אין (רק עיגול) | 24 |
תרחיש 33: ארבעה מבנים: ריפוד פנימי, סופי, ואפס ריפוד
#include <stdio.h>
#include <stddef.h>
struct p1 { short a; double b; char c; };
struct p2 { double b; short a; char c; };
struct p3 { int a; int b; };
struct p4 { char a; short b; char c; };
int main(void) {
printf("%zu %zu %zu %zu\n", sizeof(struct p1), sizeof(struct p2),
sizeof(struct p3), sizeof(struct p4));
printf("%zu %zu %zu\n", offsetof(struct p1, c), offsetof(struct p2, c),
offsetof(struct p4, c));
return 0;
}24 16 8 6
16 10 4הפלט בא מ-x86-64 עם gcc, כמו שאר הגדלים בחלק הזה.
| מבנה | פריסה בהיסטים | יישור מרבי | sizeof |
|---|---|---|---|
p1 | a ב-0..1, ריפוד 2..7, b ב-8..15, c ב-16, ריפוד 17..23 | 8 | 24 |
p2 | b ב-0..7, a ב-8..9, c ב-10, ריפוד 11..15 | 8 | 16 |
p3 | a ב-0..3, b ב-4..7 | 4 | 8 |
p4 | a ב-0, ריפוד 1, b ב-2..3, c ב-4, ריפוד 5 | 2 | 6 |
p1 ו-p2 מכילים אותם שדות, ובסדר מהגדול לקטן נחסכו 8 בתי ריפוד. ב-p3 אין ריפוד, ולכן הגודל שווה בדיוק לסכום (4 + 4).
ב-p4 השדה המיושר ביותר הוא short, ולכן אחרי הבית ה-5 מספיק להגיע לכפולה של 2, כלומר 6. כדי להגיע ל-8 היה צריך שדה שהיישור שלו 4 או 8, ואין כזה.
גודל של union
ב-union השדות אינם עומדים בשורה אלא חופפים: כולם מתחילים באותו היסט, 0, מתחילת ה-union, ושוכנים באותם בתים. לכן ערך משמעותי נשמר רק בשדה אחד בכל רגע נתון.
לכן הגדלים לא נצברים: מתחילים מהשדה שתופס הכי הרבה בתים, ומעלים אותו עד הכפולה הקרובה של היישור הגדול שיש באיברי ה-union. מי שמחבר את הגדלים, מחבר ואז מעגל, או לוקח את השדה הראשון בלבד, טועה בכל מקרה.
תרחיש 34: ארבעה union ושני מבנים שעוטפים שדה משותף
#include <stdio.h>
union a { long long l; char c[12]; };
union b { char t[3]; short s; };
union c { int i; float f; };
union d { double x; char y[3]; };
struct t1 { char kind; union { short s; int i; } v; };
struct t2 { char kind; struct { short s; int i; } v; };
int main(void) {
printf("%zu %zu %zu %zu\n", sizeof(union a), sizeof(union b),
sizeof(union c), sizeof(union d));
printf("%zu %zu\n", sizeof(struct t1), sizeof(struct t2));
return 0;
}16 4 4 8
8 12הפלט בא מ-x86-64 עם gcc.
| union | השדה הגדול | יישור מרבי | גודל |
|---|---|---|---|
a | char c[12], 12 בתים | 8 (של long long) | 12 מעוגל ל-16 |
b | char t[3], 3 בתים | 2 (של short) | 3 מעוגל ל-4 |
c | int או float, 4 בתים | 4 | 4 |
d | double, 8 בתים | 8 | 8 |
| מבנה | בית 0 | בתים 1..3 | בתים 4..7 | בתים 8..11 | גודל |
|---|---|---|---|---|---|
t1 | kind | ריפוד | s ו-i חופפים | אין | 8 |
t2 | kind | ריפוד | s ב-4..5, ריפוד 6..7 | i | 12 |
ה-union ב-t1 ויישורו 4, ולכן הוא מתחיל בהיסט 4 ותופס 4 בתים. המבנה המקונן ב-t2 גם הוא מתחיל בהיסט 4, אבל השדות שלו אינם חופפים, ולכן הוא תופס 8.
אותם בתים בשני שמות: little endian
ארבעה בתים רצופים מחזיקים מספר אחד, וכל בית הוא בעל משקל אחר. נשאר להכריע איזה בית נשמר בכתובת הנמוכה, וההכרעה הזו חשובה כש-union מאפשר לכתוב דרך שדה אחד ולקרוא דרך אחר (חוקי ב-C): הבתים אותם בתים, והתוצאה תלויה בסדר.
ב-x86 וב-x86-64 הבית בעל המשקל הנמוך ביותר יושב בכתובת הנמוכה ביותר. סדר כזה נקרא little endian.
הערך 0x00A1B2C3 | היסט 0 | היסט 1 | היסט 2 | היסט 3 |
|---|---|---|---|---|
| little endian (x86) | 0xC3 | 0xB2 | 0xA1 | 0x00 |
| big endian | 0x00 | 0xA1 | 0xB2 | 0xC3 |
ואם רוצים לשחזר את המספר מהבתים, מכפילים כל בית במשקל של מקומו: 256^k עבור היסט k, כלומר 1, 256, 65,536 ו-16,777,216 להיסטים 0 עד 3.
תרחיש 35: קריאה וכתיבה של בתים בודדים בתוך מספר
#include <stdio.h>
union view {
unsigned int val;
unsigned char octet[4];
};
int main(void) {
union view u;
u.val = 0x00A1B2C3u;
printf("%x %x\n", u.octet[0], u.octet[2]);
u.val = 0;
u.octet[3] = 2;
printf("%u\n", u.val);
return 0;
}c3 a1
33554432ב-x86-64 הבתים של 0x00A1B2C3 בזיכרון הם C3 B2 A1 00, ולכן octet[0] הוא c3 ו-octet[2] הוא a1. הפורמט %x מדפיס ספרות הקסדצימליות קטנות, בלי 0x ובלי אפסים בתחילת המספר.
אחרי האיפוס, octet[3] = 2 תורם 2 * 16777216, כלומר 33554432. במכונת big endian היינו מקבלים 0 b2 ואחר כך 2.
מערך גמיש ומערך של מבנים
נניח שרוצים מבנה עם כותרת קבועה ועם טקסט שאורכו ידוע רק בזמן ההקצאה. אפשר להצהיר כשדה אחרון char label[];, בלי גודל: זה מערך גמיש (flexible array member, מ-C99). הוא חייב לבוא אחרון, והוא יושב באותו בלוק של שאר המבנה.
החישוב הוא malloc(sizeof *m + n): החלק הקבוע של המבנה ועוד n בתים למערך. sizeof נקבע בזמן הידור, ולכן הוא מכסה רק את החלק הקבוע. אם השדות הקבועים הם int len; לבדו, sizeof הוא 4 גם אחרי malloc(sizeof *b + 8), ולא 12.
תרחיש 36: מערך גמיש שמתחיל בתוך הריפוד
#include <stdio.h>
#include <stdlib.h>
#include <stddef.h>
#include <string.h>
struct tag {
int id;
char kind;
char label[]; /* flexible array member */
};
int main(void) {
const char *text = "ping";
struct tag *t = malloc(sizeof *t + strlen(text) + 1);
if (t == NULL) return 1;
t->id = 7;
t->kind = 'q';
strcpy(t->label, text);
printf("%zu %zu %s\n", sizeof(struct tag), offsetof(struct tag, label), t->label);
free(t);
return 0;
}8 5 pingבהרצה על x86-64 עם gcc, השדות הקבועים הם int (היסטים 0..3) ו-char (היסט 4), ולכן הגודל מעוגל ל-8. המערך הגמיש מתחיל מיד אחרי השדה האחרון, בהיסט 5, כלומר בתוך מה שנראה כריפוד סופי.
הבלוק שהוקצה הוא 8 + 5 = 13 בתים, ו-5 מהם שייכים למילה ping ולתו הסיום.
בהקצאה 4 * sizeof *box מקבלים בלוק רציף אחד, שבו המבנים עומדים בשורה, כל אחד מיד אחרי קודמו. box[i] הוא המבנה ה-i בשורה.
תרחיש 37: חישוב גודל וערכים במערך של מבנים
#include <stdio.h>
#include <stdlib.h>
struct size2 { int w; int h; };
int main(void) {
struct size2 *box = malloc(4 * sizeof *box);
if (box == NULL) return 1;
for (int e = 0; e < 4; e++) {
box[e].w = e + 2;
box[e].h = box[e].w * box[e].w;
}
printf("%zu %d %d\n", 4 * sizeof *box,
box[1].w + box[3].h, box[1].h + box[3].w);
free(box);
return 0;
}32 28 14i | 0 | 1 | 2 | 3 |
|---|---|---|---|---|
box[i].w | 2 | 3 | 4 | 5 |
box[i].h | 4 | 9 | 16 | 25 |
שני int נותנים 8 בתים למבנה, ולכן ארבעה מבנים הם בלוק של 32 בתים. הסכום הנכון הוא box[1].w + box[3].h, כלומר 3 + 25 = 28.
מי שמחליף את השדות ומחשב box[1].h + box[3].w מקבל 9 + 5 = 14, ולכן חשוב לבדוק כל שדה במדויק.
טעויות נפוצות
sizeofשל struct הוא סכום השדות, או שאין ריפוד בסוף המבנה. יש ריפוד בין שדות וגם בסוף, כדי שהגודל יתחלק ביישור המרבי; הסכום נכון רק כשאין ריפוד כלל.- כל struct מעוגל בסוף לכפולה של 8, או שכל שדה תופס 8 בתים. כל שדה מיושר לפי הטיפוס שלו, והעיגול הסופי הוא ליישור הגדול ביותר שבתוך המבנה.
sizeofשל union הוא סכום השדות או גודל השדה הראשון. השדות חופפים, ולכן הגודל נקבע לפי השדה הגדול ומעוגל ליישור המרבי.- הבית בהיסט 0 של
intב-x86 הוא הבית הגבוה. x86 היא little endian, ולכן שם יושב הבית הנמוך. - המערך הגמיש, או הבתים שהוקצו לו, נכללים ב-
sizeofשל המבנה.sizeofמחושב בקומפילציה ואינו כולל אותם.
בדקו את עצמכם
מה sizeof(struct { char a; short b; int c; char d; }) ב-x86-64 עם gcc?
12: a ב-0, ריפוד 1, b ב-2..3, c ב-4..7, d ב-8, וריפוד 9..11 כדי להגיע לכפולה של 4.
מה sizeof(union { double d; char s[10]; })?
16: השדה הגדול הוא 10 בתים, והיישור המרבי הוא 8, ולכן 10 מעוגל ל-16.
העתקת struct: רדודה ועמוקה
השמה של struct מעתיקה שדה אחרי שדה
מה קורה לבלוק ב-heap כשכותבים b = a? כשמשימים מבנה למבנה, מעבירים אותו לפונקציה או מחזירים אותו, C מעתיקה כל שדה בנפרד, בלי לשאול מה השדה מייצג.
| סוג השדה | מה מועתק | התוצאה אחרי ההעתקה |
|---|---|---|
מספר (int n) | הערך | שני עותקים עצמאיים. |
מצביע (char *s) | הכתובת | לשניהם אותה כתובת, ולכן יש בלוק יחיד שנגיש משני המבנים. |
זו העתקה רדודה (shallow copy), וממנה נובע ההבדל בין שני סוגי השדות: כתיבה לבלוק דרך מבנה אחד נראית גם דרך השני, כי זה בלוק אחד, ואילו שינוי בשדה מספרי נשאר במבנה שבו נעשה.
כששני מבנים מחזיקים כתובת אחת, צריך להחליט מי הבעלים של הבלוק, כי רק לו מותר לקרוא ל-free, ורק פעם אחת. השיתוף עצמו חוקי. שחרור דרך שניהם הוא שחרור כפול, ושחרור דרך אחד משאיר לשני מצביע תלוי.
העתקה עמוקה
העתקה עמוקה (deep copy) היא פונקציה שאתם כותבים, כי C אינה עושה זאת לבד. לכל שדה מצביע היא מבצעת שלושה צעדים:
- מקצה בלוק חדש בגודל המתאים באמצעות
malloc. - מעתיקה אליו את התוכן, למשל עם
strcpy. - מציבה את הכתובת החדשה בשדה של העותק.
בסוף לכל מבנה יש בלוק פרטי משלו.
אפשר גם לשכפל רק חלק מהמצביעים, ואז רק הם נפרדים. כדי לדעת כמה free צריך סופרים בלוקים: אחרי העתקה עמוקה מלאה יש שניים, ואחרי רדודה אחד.
תרחיש 38: העתקה חלקית: כותרת פרטית, תגיות משותפות
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
struct card {
char *title;
int *tags;
int ntags;
};
/* the parameter is already a shallow copy; only the title is made private */
static struct card half_copy(struct card src) {
struct card d = src;
d.title = malloc(strlen(src.title) + 1);
if (d.title != NULL) strcpy(d.title, src.title);
return d;
}
int main(void) {
struct card a;
a.title = malloc(6);
a.tags = malloc(3 * sizeof *a.tags);
if (a.title == NULL || a.tags == NULL) return 1;
strcpy(a.title, "alpha");
a.tags[0] = 1; a.tags[1] = 2; a.tags[2] = 3;
a.ntags = 3;
struct card b = half_copy(a);
if (b.title == NULL) return 1;
b.title[0] = 'A';
b.tags[0] = 9;
b.ntags = 2;
printf("%s %s %d %d\n", a.title, b.title, a.tags[0], a.ntags);
printf("%d %d\n", a.title == b.title, a.tags == b.tags);
free(a.title);
free(b.title);
free(a.tags); /* b.tags is the same block */
return 0;
}alpha Alpha 9 3
0 1| שלב | a | b | הבלוקים |
|---|---|---|---|
חזרה מ-half_copy | title לבלוק 1, tags לבלוק 2, ntags = 3 | title לבלוק 3, tags לבלוק 2, ntags = 3 | 1: "alpha", 2: {1, 2, 3}, 3: "alpha" |
b.title[0] = 'A'; | "alpha" | "Alpha" | בלוק 3 השתנה, בלוק 1 לא |
b.tags[0] = 9; | רואה 9, 2, 3 | רואה 9, 2, 3 | בלוק 2 משותף |
b.ntags = 2; | ntags = 3 | ntags = 2 | ללא שינוי |
הפרמטר src כבר היה עותק רדוד של a, כי גם העברת מבנה לפונקציה מעתיקה שדות. רק הכותרת שוכפלה בהקצאה חדשה, ולכן הכתובות של title שונות והכתובות של tags שוות, כפי שמראה השורה השנייה בפלט.
יש שלושה בלוקים, ולכן שלוש קריאות free: על a.title, על b.title ופעם אחת על a.tags, שהוא גם b.tags.
טעויות נפוצות
- השמת
structמשכפלת גם את הבלוקים שהמצביעים שבו מצביעים אליהם. היא מעתיקה שדות בלבד, כלומר כתובות: ההעתקה רדודה. - אחרי
b = aגם שדות מספריים משותפים. הם מועתקים כערכים, ושינוי באחד אינו משנה את השני. - שני מבנים שמצביעים לאותו בלוק זו התנהגות לא מוגדרת. השיתוף חוקי; הבעיה היא שחרור כפול או גישה אחרי שחרור.
- אחרי העתקה רדודה צריך לשחרר את הבלוק דרך כל מבנה. יש בלוק אחד, ולכן
freeאחת.
בדקו את עצמכם
struct m { char *s; int len; } x, y; כש-x.s מצביע לבלוק עם "hi" ו-x.len = 2. מבצעים y = x; y.len = 5; y.s[0] = 'o';. מה הם x.len ו-x.s?
x.len נשאר 2, ו-x.s הוא "oi": השדה המספרי נפרד, והמחרוזת משותפת.
כמה קריאות free נדרשות אחרי שמשכפלים את x בהעתקה עמוקה לתוך z?
שתיים: אחת ל-x.s ואחת ל-z.s, כי יש שני בלוקים.
סיכום
הסיכום מסודר כרשימת בדיקה לשאלת מעקב: קודם מציירים ושואלים איפה כל דבר גר, אחר כך מה יכול להשתבש ואיך מונעים, ובסוף כמה בתים כל דבר תופס.
- איך מציירים? שתי רשימות נפרדות: משתנים שהם חצים, ותיבות שהן בלוקים. שלוש פעולות, שלוש תוצאות בציור: תיבה חדשה מגיעה רק מ-
malloc;q = pמצייר חץ נוסף לתיבה שכבר קיימת; ו-freeמוחקת את התיבה, והחצים נשארים תלויים. - איפה זה גר? מצביע מקומי ומשתנה מקומי במחסנית; בלוק של
mallocב-heap; גלובלי ו-staticבאזור הנתונים; ליטרל של מחרוזת באזור לקריאה בלבד. - כמה זמן זה חי? משתנה מקומי רגיל נולד מחדש בכל קריאה, ואילו
staticמקומי מאותחל פעם אחת וזוכר את ערכו. לכל קריאה, גם רקורסיבית, יש מסגרת משלה, והמסגרות מתפנות מהאחרונה לראשונה. - איזו כתובת אפשר להחזיר מפונקציה? של משתנה או מערך מקומי: לא, כי היא הופכת למצביע תלוי. של
static, של בלוק ב-heap ושל ליטרל: כן, כי הם ממשיכים להתקיים אחרי החזרה.
עכשיו הצד של ה-heap: מבקשים, משנים גודל ומשחררים.
malloc(n): מחזירהnבתים עם תוכן לא ידוע (לא מאופס). לפני כל שימוש בודקים שהתוצאה אינהNULL, ולכמות איברים מכפילים ב-sizeof. בקשה לאפס בתים עשויה להחזירNULLאו כתובת ייחודית, וגם אז אסור לגשת דרכה.calloc(n, size): מאפסת את הכול, כלומר0,0.0ו-NULL.realloc: מעבירה לבלוק החדש את התוכן עד הקטן מבין הגדלים, בלי לאתחל את התוספת, ורשאית להזיז אותו; בהקטנה נשמרת ההתחלה.realloc(NULL, n)שקולה ל-malloc(n). אם ההגדלה נכשלת, הערך המוחזר הואNULLוהבלוק הקודם נשאר ללא שינוי, ולכן קולטים את התוצאה במשתנה זמני ורק אחרי בדיקה מעדכנים את המצביע המקורי.free: מותרת עלNULLועל כתובת שקיבלתם מ-malloc,callocאוreallocועוד לא החזרתם. היא מחזירהvoidואינה משנה את המצביע. מספר הקריאות שווה למספר הבלוקים, ובמבנה מקונן משחררים מבפנים החוצה.
| תקלה | איך היא נראית | מה מונע אותה |
|---|---|---|
| דליפה | בלוק שאין אליו מצביע. אין קריסה, והזיכרון חוזר רק בסוף התהליך; valgrind מדווח definitely lost. | לשחרר לפני שהכתובת הולכת לאיבוד. |
| שימוש אחרי שחרור | קריאה או כתיבה דרך מצביע שהבלוק שלו כבר שוחרר: התנהגות לא מוגדרת, והקוד מתקמפל. | להציב NULL ולא להשאיר עותקים. |
| שחרור כפול | אותו בלוק מקבל free פעמיים: התנהגות לא מוגדרת, והקוד מתקמפל. | free אחת לבלוק, ו-p = NULL אחריה. |
| חריגה מגבולות | כתיבה אל מעבר לבלוק: התנהגות לא מוגדרת, והקוד מתקמפל. | להקצות מספיק בתים ולבדוק אינדקסים. |
| מצביע מקומי שלא אותחל | הוא אינו NULL, וכתיבה דרכו היא התנהגות לא מוגדרת. | לאתחל אותו לפני כל שימוש. |
| מערך מקומי גדול מדי | מעל 8 MB ב-Linux המחסנית נשברת ב-segmentation fault. | להקצות בלוק כזה ב-heap. |
ולבסוף הבתים והעתקות:
- מחרוזת: כדי לשמור אותה צריך
strlen + 1בתים. ב-sizeofשל מערך מחרוזת תו הסיום כלול בתוצאה, ואילו על מצביע מקבלים את גודל המצביע עצמו, 8 בבנייה של 64 סיביות.strcatדורסת את תו הסיום הישן וכותבת חדש בסוף. - מערך מול ליטרל:
char s[] = "..."הוא עותק שמותר לשנות, ואילו שינוי דרךchar *p = "..."הוא התנהגות לא מוגדרת. struct: מסדרים את השדות לפי סדר ההצהרה, וכל אחד מוצב בהיסט שמתחלק ביישור של הטיפוס שלו. בסוף מעגלים את הגודל לכפולה של היישור הגדול ביותר.union: כל השדות חופפים, ולכן מודדים את השדה הרחב ביותר ומעגלים לכפולה של היישור המרבי. ב-x86 הבית הנמוך של מספר יושב בכתובת הנמוכה, והמערך הגמיש אינו נכלל ב-sizeof.- העתקת
struct: השמה מעתיקה שדה אחרי שדה, ולכן מצביע מועתק ככתובת בלבד (העתקה רדודה). בהעתקה עמוקה יוצרים לכל מצביע בלוק משלו ומעבירים אליו את התוכן. בסוף נקראתfreeפעם אחת לכל בלוק.