שפת C - קוד
מבחנים מסכמים
קטעי קוד מכל נושאי שפת C, מעורבבים במבחנים מסכמים.
בחרו את הרמה שמתאימה לכם ואת הסט שתרצו לתרגל
חומר לימוד
מבחנים מסכמים: קריאת קוד ב-C עד הפלט, שיטת מעקב ו-21 מושגי ליבה
בכל שאלה בנושא הזה מוצגת תוכנית C קצרה, וצריך להכריע מה קורה איתה: מה היא מדפיסה, או שהיא בכלל לא מגיעה להדפסה בגלל שגיאת קומפילציה, שגיאת קישור או התנהגות לא מוגדרת.
הנושא נפתח בשיטת עבודה אחת בת שבעה צעדים שמתאימה לכל שאלה כזאת. אחריה מסוכמים 21 מושגי הליבה שהמבחנים בודקים, והנושא נסגר בטבלה מרוכזת וברשימת כללי אצבע לבדיקה אחרונה לפני שמסמנים תשובה.
- הכנת הקוד לקומפילציה: Preprocessor,
#ifndef, Macro ו-inline. - טיפוסים, ביטים והחלטות:
char,long,enum,atoi, האופרטור^(XOR) ו-switch. - מבנים, כתובות וקריאות:
struct,union, מצביע לפונקציה מהצורהint (*f)(int, int), וההבדל בין__cdeclל-__fastcall. - זיכרון ובנייה: Stack, Heap,
malloc, Object file, Linker, Makefile ו-System call.
כל מושג מגיע עם תרחישים פתורים ומעקב שורה אחר שורה, עם טעויות נפוצות שחושפות למה תשובה שגויה נראית משכנעת, ועם שאלות לבדיקה עצמית. את כל התוכניות שמוצג להן פלט קימפלו והריצו בפועל עם gcc, ולכן הפלט אמין.
gcc על Linux של 64 ביט (x86-64).שיטת המעקב: איך קוראים קוד עד הפלט
שבעה צעדים לכל שאלה
רוב הטעויות בשאלות של פלט אינן חוסר ידע אלא צעד שדולג עליו: מאקרו שנקרא כאילו היה פונקציה, break שחסר בתוך switch, או משתנה שהשתנה בתוך פונקציה בלי שהטבלה שלכם התעדכנה.
התרופה היא לחקות את המכונה: עוברים על הקוד פקודה אחר פקודה, על דף, וכותבים את מה שהשתנה. לכל אחד משבעת הצעדים יש דבר מוגדר שרושמים בו, ויש לעבור עליהם בסדר הזה.
| צעד | מה רושמים על הדף |
|---|---|
| 1. קריאת השאלה | שורה אחת: סוג התשובה המבוקש (פלט, שגיאת קומפילציה, שגיאת קישור או התנהגות לא מוגדרת) והפלטפורמה |
| 2. Preprocessor | רשימת שמות המאקרו עם הטקסט של כל אחד, ואחריה כל שורת קוד שמשתמשת במאקרו, כתובה מחדש אחרי ההחלפה ולפני כל חישוב |
| 3. משתנים | טבלה שבה כל משתנה הוא עמודה, וכל השמה מוסיפה לה שורה |
| 4. קריאות לפונקציות | טבלה נפרדת לכל קריאה, עם הפרמטרים כעותקים והמשתנים המקומיים שלה |
| 5. זיכרון ומצביעים | ציור של קופסה לכל malloc ושל חץ לכל מצביע. השמה בין מצביעים מעתיקה את החץ בלבד, ולא את הקופסה |
6. printf | זוגות של מציין וארגומנט משמאל לימין, ולצד כל מציין הטיפוס שהוא מצפה לו |
| 7. בדיקה אחרונה | שאלה אחת לפני שכותבים מספר: האם יש כתיבה לאזור קריאה בלבד, גלישת int עם סימן או שגיאת בנייה? אם כן, התשובה אינה מספר |
הגדלים בטבלה נכונים לסביבת המבחנים: gcc, Linux, ארכיטקטורת x86-64 ומודל LP64.
| טיפוס | גודל בבתים | דגשים חשובים |
|---|---|---|
char | 1 | מוגדר בתקן כבית אחד בדיוק; ב-gcc על x86-64 הוא חתום (-128 עד 127) |
short | 2 | שלם קצר עם סימן כברירת מחדל |
int, unsigned int, float | 4 | גם enum ב-gcc תופס 4 בתים, וכך גם ליטרל תו כמו 'A' |
long, long long, double | 8 | ב-Windows של 64 ביט long הוא 4 בתים בלבד, ולכן שאלות על long מציינות מערכת |
| כל סוגי המצביעים | 8 | זהה עבור int *, מצביע לפונקציה, או char * שמצביע למחרוזת של אלף תווים |
שני כללי המצביעים נראים בקוד קצר אחד:
#include <stdio.h>
void wipe(int a[]) { a[1] = 0; }
int main(void) {
int v[3] = {5, 6, 7};
wipe(v);
printf("%d %d %d\n", v[1], v[2], *(v + 2));
return 0;
}0 7 7v[2]ו-*(v + 2)נותנים את אותו איבר: ההזזה נמדדת באיברים ולא בבתים, ו-p[i]הוא כתיב מקוצר ל-*(p + i).wipeקיבלה כתובת ולא עותק, ולכן האיפוס שלה נראה גם ב-main.
טבלת משתנים: מעקב מלא
כשרושמים שורה אחרי כל שינוי, אין צורך לזכור בראש מה היה הערך לפני שלושה סיבובים. הטבלה היא הזיכרון שלכם, וקשה לדלג בה על צעד.
תרחיש 1: לולאה עם שני משתנים שמשתנים יחד
#include <stdio.h>
int main(void) {
int a = 4, sum = 1;
for (int k = 1; k <= 3; k++) {
sum += a * k;
a--;
}
printf("%d %d\n", a, sum);
return 0;
}1 17| שלב | k | sum += a * k | a-- |
|---|---|---|---|
| אתחול | - | sum = 1 | a = 4 |
| איטרציה 1 | 1 | 1 + 4 * 1 = 5 | a = 3 |
| איטרציה 2 | 2 | 5 + 3 * 2 = 11 | a = 2 |
| איטרציה 3 | 3 | 11 + 2 * 3 = 17 | a = 1 |
ההפחתה של a בסוף כל סיבוב משפיעה כבר על הסיבוב הבא: בסיבוב השני מכפילים ב-3 ולא ב-4. מי שמחשב את כל הסיבובים עם a = 4 ומוסיף את 1 ההתחלתי מקבל 25 במקום 17.
תרחיש 2: מעקב משולב על מאקרו, switch, struct ו-XOR
#include <stdio.h>
#include <stdlib.h>
#define PROD(w, h) w * h
#define CUBED(x) ((x) * (x) * (x))
#define FACTOR 4
#ifndef FACTOR
#define FACTOR 10
#endif
struct Box { char kind; int count; };
int score(int code) {
int res = 0;
switch (code) {
case 0:
res += 3;
case 1:
res += 6;
break;
default:
res += 11;
}
return res;
}
int main(void) {
struct Box b = { 'M', atoi(" 14units") };
int p = PROD(b.count - 3, FACTOR);
int q = CUBED(FACTOR - 2);
int s = score(b.count % 2) + score(5);
unsigned char byte = 255;
byte += p;
printf("%c %d %d %d %d %d %zu\n", b.kind, p, q, s, byte, b.count ^ 6, sizeof(struct Box));
return 0;
}M 2 8 20 1 8 8הצעד הראשון הוא ה-Preprocessor. FACTOR מוגדר כ-4 עוד לפני בדיקת ה-#ifndef, ולכן גוף הבדיקה נזרק, ושתי שורות ב-main הופכות לטקסט הבא:
int p = b.count - 3 * 4;
int q = ((4 - 2) * (4 - 2) * (4 - 2));| ביטוי | מה קורה בפועל | ערך |
|---|---|---|
b | atoi(" 14units") מדלג על הרווח וקורא 14 עד התו 'u' | kind='M', count=14 |
p | בלי סוגריים במאקרו PROD, הכפל קודם לחיסור: 14 - 12 | 2 |
q | הסוגריים שומרים על החיסור לפני הכפל: 2 * 2 * 2 | 8 |
s | score(0) נכנס ל-case 0, גולש ל-case 1 ועוצר (9); score(5) מגיע ל-default (11) | 20 |
byte | 255 + 2 = 257; unsigned char נחתך מודולו 256 | 1 |
b.count ^ 6 | XOR בינארי: 1110 ^ 0110 = 1000 | 8 |
sizeof(struct Box) | char בהיסט 0, שלושה בתי padding ליישור, int בהיסט 4 | 8 |
כל אחד מהפריטים האלה (מאקרו, switch, atoi, char, XOR ו-padding) מקבל חלק משלו בהמשך הנושא, ולכן כאן מספיק לעקוב אחרי השורות בטבלה.
printf, חלוקת שלמים והמרות
מחרוזת הפורמט של printf קובעת את הפלט: כל % לוקח את הארגומנט הבא בתור. אלה המציינים שחוזרים כמעט בכל מבחן:
| מציין | טיפוס מצופה ופלט | דוגמה קצרה |
|---|---|---|
%d | שלם עם סימן (int) | printf("%d", -5) מדפיס -5 |
%u | שלם ללא סימן (unsigned int) | printf("%u", 12u) מדפיס 12 |
%ld, %lu | long ו-unsigned long | printf("%lu", 4000000000UL) |
%zu | size_t (תוצאה של sizeof או strlen) | printf("%zu", sizeof(int)) מדפיס 4 |
%x, %X, %02X | בסיס 16 באותיות קטנות או גדולות; 02 מרפד באפס לשתי ספרות | printf("%02X", 13) מדפיס 0D |
%c | תו לפי קוד ASCII | printf("%c", 68) מדפיס D |
%s | רצף תווים מהכתובת ועד בית '\0' הראשון | printf("%s", "ok") מדפיס ok |
%.1f | double עם ספרה אחת אחרי הנקודה | printf("%.1f", 5 / 2.0) מדפיס 2.5 |
ושלושה כללי חישוב שמכריעים הרבה שאלות:
- אופרנד
doubleהופך את החלוקה לעשרונית:5 / 2.0שווה2.5, בעוד ש-5 / 2שווה2. - ערך עשרוני שנכנס לפרמטר
intנחתך בכניסה: אלthird(8.9)מגיע8, והשבר נעלם עוד לפני שגוף הפונקציה רץ. - חלוקת שלמים זורקת את השארית לכיוון אפס:
9 / 4הוא2, וגם-9 / 4הוא-2(ולא-3).
דבר דומה קורה בחישובים עם char ו-short: הם עולים זמנית ל-int בתוך הביטוי, והערך נחתך לגודל המקורי רק כשמשימים אותו חזרה למשתנה קטן.
תרחיש 3: מצייני פורמט, חלוקת שלמים וקיצוץ פרמטר
#include <stdio.h>
int third(int n) { return n / 3; }
int main(void) {
printf("%d %u %x %02X %c %.1f\n", 8 - 3, 12u, 240, 13, 68, 5 / 2.0);
printf("%d %d %d %d\n", 9 / 4, -9 / 4, 9 % 4, third(8.9));
return 0;
}5 12 f0 0D D 2.5
2 -2 1 2- השורה הראשונה:
240בבסיס 16 הואf0,%02Xמרפד את13ל-0D, והקוד68מוצג כתוD. - השורה השנייה: בקריאה
third(8.9)הפרמטרnמקבל8, ולכן8 / 3מחזיר2.
שאלות "מה קורה": קומפילציה, קישור, התנהגות לא מוגדרת ודליפה
כשהשאלה היא מה יקרה ולא מה יודפס, יש ארבע תשובות אפשריות שונות מאוד זו מזו, וצריך לשייך את הקוד לאחת מהן. (המושגים include guard, Linker ו-object file שמופיעים בטבלה מוסברים בהמשך הנושא.)
| תוצאה | מתי היא מתרחשת | דוגמה אופיינית |
|---|---|---|
| שגיאת קומפילציה | המהדר מזהה בעיה בתוך קובץ .c יחיד | הגדרה כפולה של משתנה גלובלי מאותחל באותו קובץ (כמו כותרת בלי include guard שנכללה פעמיים) |
| שגיאת קישור | ה-Linker לא מצליח לאחד קבצי object | undefined reference לפונקציה שהוצהרה ולא מומשה, או multiple definition של משתנה שהוגדר בשני קבצי .c |
| התנהגות לא מוגדרת (UB) | הקוד עובר קומפילציה, אך התקן מתיר כל תוצאה | שינוי תו במחרוזת ליטרלית, free למצביע זבל, שימוש אחרי free, גלישת int עם סימן |
| דליפת זיכרון | בלוק ב-Heap שאבדה אליו הגישה ולא שוחרר | התוכנית רצה ומדפיסה כרגיל; מערכת ההפעלה משיבה את הזיכרון עם סיום התהליך |
התנהגות לא מוגדרת היא מצב של זמן ריצה: הקוד עובר קומפילציה, אבל התקן אינו קובע מה ייעשה בו, כמו בכתיבה לליטרל, בשימוש אחרי free או בגלישת int עם סימן. זה שונה משגיאת קומפילציה, שבה המהדר חייב לדווח ולעצור, למשל בהשמה למשתנה const int אחרי האתחול שלו.
לכן בוחרים בהתנהגות לא מוגדרת רק כשאפשר להצביע על פעולה מסוימת בקוד שהתקן משאיר פתוחה: קריאה ממשתנה מקומי שלא אותחל, גישה מחוץ לגבולות מערך, גלישת int עם סימן, שינוי ליטרל מחרוזת או הפניה למצביע ששוחרר. אם אין פעולה כזאת, עוקבים אחרי הפלט כרגיל. כשיש, תשובה עם מספר מסוים שגויה, וגם "תמיד מסתיים בקריסה", כי על אותו קוד אפשר לקבל פעם קריסה ופעם ריצה שקטה.
ההבדל הקלאסי הוא בין שתי הצהרות שנראות כמעט זהות:
#include <stdio.h>
int main(void) {
char word[] = "cold"; /* own modifiable copy on the stack */
word[0] = 'b';
printf("%s\n", word);
/* char *lit = "cold"; lit[0] = 'b'; compiles, but is undefined behaviour */
return 0;
}boldבגרסה עם char *lit = "cold"; הכתיבה lit[0] = 'b' היא התנהגות לא מוגדרת: המצביע מכוון לליטרל שיושב באזור קריאה בלבד, וב-Linux זה מסתיים בדרך כלל ב-segmentation fault. ובכל זאת אין שגיאת קומפילציה: ב-C הטיפוס של ליטרל מחרוזת הוא מערך של char ולא של const char, ולכן ההשמה ל-char * חוקית.
טעויות נפוצות
- אם יש בקוד התנהגות לא מוגדרת, המהדר יעצור ויודיע על שגיאה. המהדר אינו חייב לגלות אותה, ולכן הקוד לרוב מתקמפל בשקט והבעיה צצה בריצה או רק כשמפעילים אופטימיזציות.
- כשאותו משתנה מוגדר פעמיים בקובץ אחד, מי שמתלונן הוא ה-Linker. שתי ההגדרות נמצאות ביחידת קומפילציה אחת, ולכן המהדר מזהה את הכפילות ועוצר לפני שהקישור בכלל מתחיל.
- תוכנית שמדליפה זיכרון תקרוס או תדפיס משהו אחר. הדליפה לא נוגעת בלוגיקה: התוכנית מדפיסה את אותו פלט, והבלוק פשוט נשאר תפוס עד שהתהליך מסתיים.
- חלוקת שלמים מעגלת, ולכן
11 / 4הוא3(או2.75). התוצאה היא2: השארית נזרקת בלי עיגול, וגם-11 / 4הוא-2ולא-3.
בדקו את עצמכם
מה מדפיס printf("%d %.1f %c\n", 23 / 6, 23 / 6.0, 'a' + 2);?
3 3.8 c. החלוקה בין שלמים נחתכת ל-3, החלוקה ב-6.0 נותנת 3.83... שמוצג כ-3.8, והערך 'a' + 2 הוא 99, קוד ה-ASCII של 'c'.
בשתי תוכניות מופיעה הכתיבה w[0] = 'b';, בראשונה אחרי char w[] = "kite"; ובשנייה אחרי char *w = "kite";. במה שונות התוצאות?
הראשונה חוקית ומדפיסה bite. בשנייה w מכוון לליטרל לקריאה בלבד, ולכן הכתיבה היא התנהגות לא מוגדרת (בדרך כלל segmentation fault ב-Linux), בלי שגיאת קומפילציה.
Preprocessor ו-#ifndef
מה ה-Preprocessor עושה ו-gcc -E
המהדר לא רואה את שורות ה-# שכתבתם. לפניו פועל שלב שנקרא Preprocessor, שמקבל את קובץ המקור כרצף תווים, מבצע בו החלפות והדבקות ומעביר הלאה טקסט נקי. בשלב הזה אין עדיין טיפוסים, משתנים, פונקציות או ערכים שנקבעים בזמן ריצה: יש רק מחרוזות.
ההוראות שהוא מטפל בהן הן #include, #define, #undef, #if, #ifdef, #ifndef, #elif, #else, #endif, #error ו-#pragma. הנה ארבע שאלות ששואלים עליו, עם תשובה לכל אחת:
| שאלה | תשובה |
|---|---|
| באיזה סדר הוא קורא את הקובץ? | פעם אחת, מהשורה הראשונה לאחרונה. הגדרה משפיעה רק על השורות שנמצאות אחריה |
האם #define בתוך main מוגבל ל-main? | לא. הסוגריים המסולסלים לא קיימים מבחינתו, ולכן ההגדרה תקפה בכל פונקציה שנכתבה מתחתיה |
מה #include <stdio.h> מכניס לקובץ? | את טקסט הכותרת, כלומר הצהרות. קוד הפונקציות אינו נכנס, והחיבור אליו נעשה מאוחר יותר ב-Linker |
| מה קורה להערות, ואיך רואים את התוצאה כולה? | כל הערה נמחקת ומוחלפת ברווח יחיד לפני שההוראות נקראות. הפקודה gcc -E file.c עוצרת אחרי העיבוד המקדים, כך שלא נוצרים assembly, object file או קובץ הרצה, ומציגה ל-stdout את הטקסט שנשאר |
תרחיש 4: gcc -E -P עם הגדרה משורת הפקודה
/* calc.c */
#define RATE 5
#ifndef LIMIT
#define LIMIT 100
#endif
int total = RATE * 4; /* compute total */
int cap = LIMIT;gcc -E -P calc.cint total = 5 * 4;
int cap = 100;gcc -E -P -DLIMIT=9 calc.cint total = 5 * 4;
int cap = 9;gcc -E -P -DLIMIT calc.cint total = 5 * 4;
int cap = 1;- בלי
-Pהפלט כולל גם שורות סימון כמו# 1 "calc.c", שמציינות את מקור השורות. הדגל מסיר אותן, ונשאר טקסט נקי. - ב-
totalנשאר5 * 4: ה-Preprocessor החליף שם בטקסט ולא חישב, והכפל ייעשה רק בקומפילציה. ההערה נעלמה. - ב-
-DLIMIT=9המאקרו הוגדר מראש, ולכן ה-#ifndefדילג על100. ב--DLIMITלבדו הערך הוא1, והדגל-ULIMITמבטל הגדרה קיימת.
#if, #ifdef, #ifndef ו-#else
הוראות התנאי מחליטות אילו שורות ימשיכו אל המהדר. ענף שלא נבחר נמחק מהטקסט כאילו מעולם לא נכתב.
| הוראה | התנאי להשארת הקוד | הערה |
|---|---|---|
#ifdef NAME | NAME מוגדר כמאקרו | שקול ל-#if defined(NAME) |
#ifndef NAME | NAME אינו מוגדר כמאקרו | שקול ל-#if !defined(NAME) |
#if expr | הביטוי השלם expr שונה מ-0 | מחושב בזמן ה-Preprocessor |
#elif, #else | ענפי המשך וחלופה | כל בלוק תנאי חייב להסתיים ב-#endif |
ארבע נקודות שמבלבלות בשאלות תנאי:
#ifעל שם שלא הוגדר כמאקרו אינו נכשל: השם נקרא כ-0, התנאי שקרי, וענף ה-#elseנבחר.#define VERBOSEבלי גוף עדיין מגדיר אתVERBOSE:#ifdef VERBOSEמתקיים ו-#ifndef VERBOSEלא.#ifndefמכיר שמות מאקרו בלבד. משתנה, פונקציה או קבועenumבעלי אותו שם אינם נחשבים.- דפוס ברירת המחדל הוא
#ifndef Xואחריו#define Xעם ערך. אםXכבר הוגדר בקובץ או בדגל-DX=..., הגדרת ברירת המחדל מדולגת.
תרחיש 5: שרשרת תנאים ב-Preprocessor
#include <stdio.h>
#define VERBOSE
#define WIDTH 6
#ifndef WIDTH
#define WIDTH 20
#endif
#ifdef VERBOSE
#define GAP 3
#else
#define GAP 8
#endif
#if WIDTH * GAP >= 18
#define RES (WIDTH + GAP)
#else
#define RES 0
#endif
#if UNDEFINED_FLAG
#define BONUS 5
#else
#define BONUS 50
#endif
int main(void) {
printf("%d %d\n", RES * 2, BONUS);
return 0;
}18 50WIDTHהוגדר כ-6לפני בדיקת ה-#ifndef, ולכן20לא נכנס.VERBOSEקיים (גם בלי גוף), ולכןGAPהוא3ולא8.- התנאי
6 * 3 >= 18אמת, ולכןRESמוגדר כטקסט(WIDTH + GAP). UNDEFINED_FLAGנקרא כ-0, ולכןBONUSהוא50.- בשורת ה-
printf,RES * 2הופך ל-(6 + 3) * 2, כלומר18.
Include guard
שורה כמו int max_items = 5; היא הגדרה, ואסור להגדיר את אותו משתנה פעמיים באותה יחידת קומפילציה. מצב כזה נוצר כשכותרת נכללת פעמיים: למשל קובץ .c שכולל את הכותרת וגם כותרת אחרת שכוללת אותה בעצמה.
תרחיש 6: כותרת שנכללת פעמיים בלי הגנה
/* defs_bad.h (no guard) */
int max_items = 5;
/* s06_bad.c */
#include <stdio.h>
#include "defs_bad.h"
#include "defs_bad.h"
int main(void) {
printf("%d\n", max_items);
return 0;
}In file included from s06_bad.c:3:
defs_bad.h:1:5: error: redefinition of 'max_items'
1 | int max_items = 5;
| ^~~~~~~~~
In file included from s06_bad.c:2:
defs_bad.h:1:5: note: previous definition of 'max_items' with type 'int'
1 | int max_items = 5;
| ^~~~~~~~~התוצאה היא שגיאת קומפילציה ולא שגיאת קישור. המהדר רואה את שתי ההגדרות של max_items יחד, ולכן הוא נעצר עוד לפני שה-Linker מתחיל לעבוד.
הפתרון הוא include guard, תבנית שעוטפת את תוכן הכותרת:
/* math_api.h */
#ifndef MATH_API_H
#define MATH_API_H
int clamp_val(int x); /* declaration only */
#endif| מצב בעיבוד המקדים | מה קורה לגוף הכותרת |
|---|---|
ההכללה הראשונה: MATH_API_H עדיין לא מוגדר | תנאי ה-#ifndef מתקיים, הגוף עובר למהדר, ושורת ה-#define רושמת את השם |
הכללה נוספת באותו קובץ .c: השם כבר רשום | התנאי נכשל, וכל השורות עד ה-#endif נשמטות |
אילו defs_bad.h היה עטוף כך, עם שם שומר כמו DEFS_OK_H, ההכללה השנייה הייתה מתרוקנת והתוכנית מדפיסה 5.
| שאלה | תשובה |
|---|---|
| איך בוחרים את שם השומר? | כל שם מאקרו שאינו תפוס מתאים. זה שם של מאקרו ולא של משתנה, ונהוג לגזור אותו משם הקובץ, אבל אין קשר בינו לשמות הפונקציות שבכותרת |
| האם יש חלופה קצרה יותר? | שורה אחת, #pragma once, בראש הכותרת, במקום שלוש שורות השומר. התקן אינו מגדיר אותה, אבל gcc, clang ו-MSVC מכירים אותה |
net.h מגדירה int retries = 3; ושני קבצים, a.c ו-b.c, כוללים אותה: כל קובץ מעובד מאפס, השומר אינו מתערב, ושני קבצי ה-object מכילים את retries. ה-Linker יגיד multiple definition, והתיקון הוא להצהיר בכותרת extern int retries; ולהגדיר את המשתנה רק ב-a.c.מאקרו מורחב בנקודת השימוש ו-#undef
מי שקורא #define DOUBLE_BASE (BASE * 2) כאילו DOUBLE_BASE כבר שווה 10 מתייחס למאקרו כאל משתנה. בפועל נשמרת המחרוזת (BASE * 2), וההחלפה של BASE קורית רק בשורה שבה DOUBLE_BASE נקרא, לפי הערך שתקף שם.
תרחיש 7: שינוי מאקרו באמצע הקובץ עם #undef
#include <stdio.h>
#define BASE 5
#define DOUBLE_BASE (BASE * 2)
#define PRINT_VAL() printf("%d ", DOUBLE_BASE)
int main(void) {
PRINT_VAL();
#undef BASE
#define BASE 15
PRINT_VAL();
printf("%d\n", DOUBLE_BASE + 3);
return 0;
}10 30 33- הקריאה הראשונה ל-
PRINT_VAL():BASEהוא5באותו רגע, ולכן מודפס10. #undef BASEואחריו#define BASE 15משנים את הטקסט שיחליף אתBASEמכאן והלאה, ולכן הקריאה השנייה מדפיסה30.DOUBLE_BASE + 3מתרחב ל-(15 * 2) + 3, כלומר33.
#undef NAME מבטל את ההגדרה מהשורה הזו והלאה, ואז מותר להגדיר את NAME מחדש. הגדרה חדשה בטקסט שונה בלי #undef לפניה לא נחסמת, אבל gcc מזהיר redefined.
טעויות נפוצות
- אחרי
#define LIMIT 50יש בזיכרון משתנה בשםLIMIT. אין כזה: לפני הקומפילציה כלLIMITהוחלף בטקסט, ולכן אין לו כתובת ואי אפשר לקחת אותה. #define DEBUGבלי גוף משאיר אתDEBUGלא מוגדר. ההגדרה קיימת, רק שהגוף ריק, ולכן#ifdef DEBUGמתקיים.#if MODEכש-MODEלא הוגדר יגרום לשגיאת קומפילציה. השם נקרא כ-0, התנאי שקרי והקומפילציה ממשיכה.#ifndef Xמגדיר אתXאם הוא חסר. הוא רק בודק. ההגדרה נעשית בשורת#define Xשמתחתיו.- עם include guard, שני קבצי
.cיכולים להגדיר אותו משתנה גלובלי בלי בעיה. כל קובץ.cמעובד מאפס, כך שהשומר אינו רואה את הקובץ השני, והקישור ייכשל ב-multiple definition. #include <math.h>מוסיף לתוכנית את קוד הפונקציות המתמטיות. הכותרת נותנת הצהרות בלבד. את הקוד מביא ה-Linker, ולשם כך נדרש דגל כמו-lm.
בדקו את עצמכם
בקובץ מופיעים בסדר הזה #define W 2, #define AREA (W * W), #undef W, #define W 5, ובסוף printf("%d", AREA + 1);. מה יודפס?
26. AREA מורחב רק בשורת ה-printf, ולכן הוא (5 * 5) + 1.
בקובץ יש #if VERB, אחריו printf("on");, אחר כך #else עם printf("off"); ו-#endif. מה מדפיסה התוכנית כשמקמפלים בלי דגלים, ומה כשמקמפלים עם gcc -DVERB?
בלי דגלים off: VERB אינו מאקרו, נקרא כ-0, ואין שגיאה. עם -DVERB הוא מוגדר כ-1, ולכן מודפס on.
Macro: החלפת טקסט
סוגריים וקדימות אופרטורים
נניח #define AREA(w, h) w * h. מה מחזירה AREA(2 + 3, 4)? מי שעונה 20 חישב את 2 + 3 לפני ההדבקה, אבל המהדר מקבל את הטקסט 2 + 3 * 4, שערכו 14.
מאקרו רק מעתיק טקסט, ואת סדר הפעולות קובעת הקדימות הרגילה של C. לכן בכל שאלה כותבים קודם את השורה כפי שהמהדר רואה אותה, ורק בה מחשבים.
כך נראה הדירוג, מהקדימות הגבוהה לנמוכה:
| קדימות (מגבוה לנמוך) | אופרטורים |
|---|---|
| 1 | * / % |
| 2 | + - |
| 3 | << >> |
| 4 | < <= > >= |
| 5 | == != |
| 6 | & (AND בינארי) |
| 7 | ^ (XOR בינארי) |
| 8 | | (OR בינארי) |
| 9 | && |
| 10 | || |
| 11 | ?: |
| 12 | = += -= ^= |
שני יחסים שכדאי לשנן: + קודם ל-<<, ו-<< קודם ל-|. מכאן ש-a + b << c נקרא (a + b) << c, ו-a | b << c נקרא a | (b << c).
תרחיש 8: ארבע קריאות מאקרו ללא סוגריים
#include <stdio.h>
#define QUAD(x) x * 4
#define ADD(a, b) a + b
#define SHL(v, n) v << n
int main(void) {
int r1 = QUAD(3 + 1);
int r2 = 5 * ADD(2, 3);
int r3 = SHL(1, 3) + 2;
int r4 = SHL(8 | 2, 1);
printf("%d | %d | %d | %d\n", r1, r2, r3, r4);
return 0;
}7 | 13 | 32 | 12| שימוש בקוד | טקסט אחרי ההחלפה | סדר החישוב בפועל | תוצאה |
|---|---|---|---|
QUAD(3 + 1) | 3 + 1 * 4 | כפל לפני חיבור: 3 + 4 | 7 |
5 * ADD(2, 3) | 5 * 2 + 3 | כפל לפני חיבור: 10 + 3 | 13 |
SHL(1, 3) + 2 | 1 << 3 + 2 | חיבור לפני הזזה: 1 << 5 | 32 |
SHL(8 | 2, 1) | 8 | 2 << 1 | הזזה לפני |: 8 | 4 | 12 |
בקומפילציה עם -Wall gcc אפילו מתריע על המקרה השלישי: suggest parentheses around '+' inside '<<'. מי שמחשב את הארגומנטים לפני ההדבקה מקבל 16, 25, 10 ו-20, וכל אלה שגויים.
הצורה הבטוחה מקיפה בסוגריים כל פרמטר לחוד וגם את הגוף כולו, למשל #define QUAD(x) ((x) * 4) ו-#define SHL(v, n) ((v) << (n)).
לסיום, שלוש שאלות על ההגדרה עצמה:
| שאלה | תשובה |
|---|---|
| מה ההבדל בין מאקרו אובייקט למאקרו דמוי-פונקציה? | הראשון (#define N 10) מחליף שם בטקסט קבוע. השני (#define AREA(w, h) ((w) * (h))) מקבל ארגומנטים ומציב את הטקסט שלהם בגוף. בעברית מקובל גם "מאקרו בצורת אובייקט" ו"מאקרו בצורת פונקציה" |
מה קורה אם יש רווח בין השם לסוגר, כמו ב-#define AREA (w, h) ...? | מתקבל מאקרו אובייקט בשם AREA שהטקסט שלו מתחיל ב-(w, h), ולכן קריאה עם ארגומנטים לא תעבוד כמצופה |
למה אסור לסיים #define N 10; בנקודה-פסיק? | הנקודה-פסיק נכנסת לטקסט. השורה int y = N + 1; הופכת ל-int y = 10; + 1;, ו-y מקבל 10 ולא 11 |
ארגומנט שמוערך פעמיים
כשמעבירים p++ לפונקציה, p גדל פעם אחת, כי הפונקציה מקבלת ערך. במאקרו מועבר טקסט, והוא נכנס מחדש בכל מקום שבו שם הפרמטר מופיע בגוף, ולכן תופעת הלוואי של הארגומנט (p++ או קריאה שמקדמת מונה) חוזרת על עצמה בכל הופעה.
תרחיש 9: הערכה כפולה ב-LARGER עם p++ ומונה
#include <stdio.h>
static int calls = 0;
int next_call(void) { return ++calls; }
#define LARGER(x, y) ((x) > (y) ? (x) : (y))
int main(void) {
int p = 7, q = 3;
int r1 = LARGER(p++, q);
printf("%d %d\n", r1, p);
int r2 = LARGER(p++, 50);
printf("%d %d\n", r2, p);
int r3 = LARGER(next_call(), 0);
printf("%d %d\n", r3, calls);
return 0;
}8 9
50 10
2 2- בקריאה הראשונה התנאי
7 > 3אמת ו-pנהיה8. הענף(p++)מחזיר8ומקדם אתpל-9. - בשנייה התנאי
9 > 50שקרי ו-pנהיה10, והענף שנבחר הוא50, כך שרק הגדלה אחת קרתה. - בשלישית הקריאה שבתנאי מחזירה
1והקריאה שבענף מחזירה2, ולכןcallsנעצר על2.
למה LARGER(p++, q) עדיין מוגדר היטב? אחרי ההרחבה מתקבל ((p++) > (q) ? (p++) : (q)), ול-?: יש נקודת רצף אחרי התנאי, כך שההגדלה בתנאי מסתיימת לפני שהענף נבחר.
אם התנאי מתקיים, p עולה פעמיים והתוצאה היא הערך שאחרי העלייה הראשונה: עבור p = 7 ו-q = 3 מתקבל 8, ו-p נעצר על 9. אם התנאי שקרי, העלייה היחידה היא זו שבתנאי.
| קריאה | אחרי ההרחבה | האם התוצאה מוגדרת בתקן |
|---|---|---|
LARGER(p++, q) | ((p++) > (q) ? (p++) : (q)) | כן: נקודת רצף בין ההגדלה שבתנאי להגדלה שבענף |
POW2(p++) עם #define POW2(n) ((n) * (n)) | ((p++) * (p++)) | לא: התקן אוסר לשנות אותו משתנה פעמיים בלי נקודת רצף ביניהם, וקוד כזה הוא התנהגות לא מוגדרת |
מאקרו של כמה פקודות
קריאה למאקרו נראית כמו פקודה אחת, אבל אם הגוף שלו כולל ; באמצע, אחרי ההדבקה יש שתי פקודות. כשהקריאה נמצאת מתחת ל-if בלי סוגריים מסולסלים, התנאי אוחז רק בראשונה.
תרחיש 10: if שתופס רק את הפקודה הראשונה במאקרו
#include <stdio.h>
#define CLEAR_BAD(v) v = 0; printf("cleared ")
#define CLEAR_OK(v) do { v = 0; printf("cleared "); } while (0)
int main(void) {
int a = 4;
if (a > 10)
CLEAR_BAD(a);
printf("%d\n", a);
int b = 4;
if (b > 10)
CLEAR_OK(b);
printf("%d\n", b);
return 0;
}cleared 4
4הרחבת if (a > 10) CLEAR_BAD(a); היא if (a > 10) a = 0; printf("cleared ");. התנאי 4 > 10 שקרי ולכן a נשאר 4, אבל ה-printf יושב מחוץ ל-if ומדפיס cleared . ב-CLEAR_OK כל הגוף הוא פקודה אחת, ולכן אין הדפסה.
| צורת הגוף | מה המהדר מקבל מתחת ל-if |
|---|---|
| שתי פקודות חשופות | שתי פקודות נפרדות: רק הראשונה תלויה בתנאי |
do { ... } while (0) סביב הגוף | פקודה אחת שלמה שכולה תלויה בתנאי, וה-; שבסוף הקריאה משלים אותה |
| גוף שנכתב על כמה שורות | כל שורה חוץ מהאחרונה מסתיימת ב-\, כדי שההגדרה תישאר שורה לוגית אחת |
האופרטורים # ו-##
שני אופרטורים של ה-Preprocessor מופיעים בגוף של מאקרו. #x דורש פרמטר, ולכן קיים רק במאקרו דמוי-פונקציה, ואילו ## עובד גם במאקרו אובייקט (#define AB a##b), אם כי נפוץ בעיקר עם פרמטרים:
#x(Stringizing) עוטף את הטקסט המדויק של הארגומנט במירכאות, והתוצאה היא מחרוזת ליטרלית.a##b(Token pasting) מאחד שני טוקנים לשם אחד, כך ש-JOIN(idx, 3)נהיהidx3.
המלכודת המרכזית היא שארגומנט הצמוד ל-# או ל-## אינו מורחב קודם. הטבלה מראה זאת עם #define CAP 32, #define TXT(x) #x ו-#define XTXT(x) TXT(x):
| ביטוי | תוצאה | הסיבה |
|---|---|---|
TXT(CAP) | "CAP" | הארגומנט צמוד ל-#, ולכן נשאר טקסט גולמי |
XTXT(CAP) | "32" | ב-XTXT הפרמטר אינו צמוד ל-#, אז CAP מורחב ל-32 לפני הקריאה ל-TXT |
JOIN(x, y) | השם xy | ## מדביק שמות, והתוצאה היא המשתנה xy ולא מספר שנבנה מהערכים של x ו-y |
"ab" "cd" | "abcd" | שתי מחרוזות ליטרליות סמוכות מתמזגות בזמן קומפילציה |
שני כללים משלימים: מאקרו בסגנון printf(#v " => %d\n", v) מדפיס את שם הארגומנט ואחריו את ערכו, ומאקרו לעולם אינו מורחב בתוך מירכאות של מחרוזת ליטרלית.
תרחיש 11: הדבקת טוקנים, מחרוזות והרחבה דו-שלבית
#include <stdio.h>
#define CAP 32
#define TXT(x) #x
#define XTXT(x) TXT(x)
#define JOIN(a, b) a##b
#define TRACE(v) printf(#v " => %d\n", v)
int main(void) {
int xy = 7, x = 2, y = 5;
int idx3 = 25;
printf("%s %s\n", TXT(CAP), XTXT(CAP));
printf("%d\n", JOIN(idx, 3) + JOIN(x, y));
TRACE(JOIN(x, y));
TRACE(x + y);
printf("%s\n", TXT(item) " is " "ready");
return 0;
}CAP 32
32
JOIN(x, y) => 7
x + y => 7
item is readyב-TRACE(JOIN(x, y)) המופע #v מקבל את הטקסט הגולמי, ולכן מודפס JOIN(x, y). המופע הרגיל v מורחב ל-xy, ששווה 7.
טעויות נפוצות
- בקריאה למאקרו הארגומנט הופך לערך אחד לפני שמשתמשים בו, כמו בפונקציה. מוחלף טקסט, והקדימות של הביטוי המשולב היא שמכריעה, ולכן בלי סוגריים התוצאה משתבשת.
- אם הארגומנט הוא
k++, המשתנה גדל פעם אחת בכל קריאה למאקרו. הטקסטk++מודבק בכל מקום שבו הפרמטר מופיע בגוף, וכל הדבקה מגדילה. TXT(CAP)מדפיס32. ארגומנט הצמוד ל-#אינו עובר הרחבה. כדי לקבל את הערך צריך מאקרו עוטף כמוXTXT.JOIN(x, y)מייצר מספר שמורכב מהערכים של המשתנים.##פועל על שמות: מתקבל המזההxy, שהוא משתנה אחר לגמרי.- אחרי
ifבלי סוגריים מסולסלים, מאקרו בן שתי פקודות כולו תלוי בתנאי. רק הפקודה הראשונה תלויה בו. הכול נכנס לתנאי רק כשעוטפים ב-do { ... } while (0).
בדקו את עצמכם
נתון #define DIFF(a, b) a - b. מה הערך של 10 - DIFF(7, 3)?
0. הטקסט מתרחב ל-10 - 7 - 3, ולא ל-10 - 4.
נתונים #define PEAK(a, b) ((a) > (b) ? (a) : (b)), int n = 4; ו-int m = PEAK(n++, 4);. מה ערכי m ו-n?
m הוא 4 ו-n הוא 5. התנאי 4 > 4 שקרי ומעלה את n ל-5, והענף שנבחר הוא (b), כך שה-n++ השני אינו רץ.
inline מול Macro
מה inline עושה
כשקוראים תוכנית כדי לדעת מה היא מדפיסה, אפשר להתעלם מהמילה inline: היא משנה רק את קוד המכונה, ולא את התוצאה. הפונקציה נשארת פונקציה רגילה, וכל ארגומנט מחושב פעם אחת לפני הכניסה אליה ומומר לטיפוס הפרמטר.
| שאלה | תשובה |
|---|---|
מה inline מבקש מהמהדר? | מ-C99 ואילך: להציב (בעברית גם "לשלב") את גוף הפונקציה במקום הקריאה, וכך לחסוך את הקפיצה אליה והחזרה ממנה |
| האם המהדר חייב להיענות? | לא. הוא רשאי להתעלם, ורשאי גם להטמיע פונקציה שלא סימנתם. ב-gcc -O0 אין הטמעה בכלל |
| אילו פונקציות כמעט אף פעם לא יוטמעו? | רקורסיביות, כאלה שנקראות דרך מצביע שהיעד שלו לא ידוע בקומפילציה, וגדולות מאוד |
| למה לא לסמן הכול? | כל הטמעה מעתיקה את הגוף למקום הקריאה. כשהגוף גדול והקריאות רבות, קובץ ההרצה גדל, ולכן הסימון מתאים לפונקציות קצרות שנקראות הרבה |
עוד פרט מעשי נוגע לכותרות. נסו להגדיר inline בלי static ולקרוא לפונקציה מ-main:
#include <stdio.h>
inline int bump(int v) { return v + 1; }
int main(void) {
printf("%d\n", bump(4));
return 0;
}לפי C99 הצהרה כזאת אינה יוצרת גרסה חיצונית של bump. ב-gcc -O0 הקריאה נשארת קריאה אמיתית והקישור נכשל ב-undefined reference to 'bump', וב-gcc -O2 הקריאה מוטמעת והתוכנית מדפיסה 5.
הניסוי מסביר את ההרגל בכותרות: עם static לכל קובץ .c יש גרסה מקומית של הפונקציה, שאף קובץ אחר אינו רואה, ולכן אין התנגשות בקישור, וגם אין תלות בהחלטת המהדר אם להטמיע.
אותו קוד כמאקרו וכפונקציה
| היבט | Macro | פונקציית inline |
|---|---|---|
| שלב הטיפול | Preprocessor (טקסט לפני קומפילציה) | המהדר (Compiler) |
| ארגומנט עם תופעת לוואי | מורץ בכל מופע של הפרמטר בגוף | מחושב פעם אחת לפני הכניסה לפונקציה |
| קדימות אופרטורים | עלולה להישבר בלי סוגריים מלאים | בטוחה: התוצאה היא ערך יחיד |
| בדיקת והמרת טיפוסים | אין (10.0 נשאר double) | מתבצעת המרה לטיפוס הפרמטר (10.0 ל-int הופך ל-10) |
| טווח (scope) ודיבוג | בלי טווח ובלי סמל לדיבוג | קיימים כמו בכל פונקציה רגילה |
תרחיש 12: אותה פעולה בשתי צורות: ערך מוחלט והכפלה
#include <stdio.h>
#define ABS_M(x) ((x) < 0 ? -(x) : (x))
static inline int abs_i(int x) { return x < 0 ? -x : x; }
#define SCALE_M(x) x * 10
static inline int scale_i(int x) { return x * 10; }
static int level = -3;
int feed(void) { return level++; }
int main(void) {
int a = ABS_M(feed());
int b = abs_i(feed());
printf("%d %d %d\n", a, b, level);
double d = 2.9;
printf("%.1f %d\n", ABS_M(-d), abs_i(-d));
printf("%d %d\n", SCALE_M(4 + 1), scale_i(4 + 1));
return 0;
}2 1 0
2.9 2
14 50מה קורה כשהארגומנט הוא קריאה שמקדמת מונה? ABS_M(feed()) מדביק את הקריאה פעמיים: אחת בתנאי, שמחזירה -3, ואחת בענף השלילה, שמחזירה -2 והופכת ל-2. abs_i(feed()) קורא ל-feed פעם אחת בלבד, מקבל -1 ומחזיר 1. ההקפצות בסך הכול הן שלוש, ולכן level מסיים על 0.
מה קורה לערך עשרוני? במאקרו -d נשאר double, ולכן ABS_M(-d) נותן 2.9. בפונקציה הארגומנט נחתך ל-int בכניסה, מ--2.9 ל--2, והתוצאה היא 2.
ומה עם קדימות? SCALE_M(4 + 1) מתרחב ל-4 + 1 * 10, כלומר 14, בעוד ש-scale_i(4 + 1) מקבל 5 ומחזיר 50.
טעויות נפוצות
- המילה
inlineמחייבת את המהדר לפרוס את הגוף בכל קריאה. זו המלצה בלבד: המהדר רשאי להתעלם ממנה, וב--O0אינו מטמיע כלל. - כמו במאקרו, ארגומנט של פונקציית
inlineמוערך בכל הופעה של הפרמטר בגוף. זו פונקציה אמיתית: הארגומנט מחושב פעם אחת לפני הכניסה, והגוף רואה רק את הערך שלו. - הוספת
inlineיכולה לשנות את הפלט של התוכנית. היא משפיעה על המהירות ועל גודל קוד המכונה, אבל לא על התוצאה של החישוב. - פונקציה שמסומנת
inlineתמיד רצה מהר יותר. הטמעה של גוף גדול בהרבה אתרי קריאה מנפחת את הקוד ופוגעת ביעילות ה-cache.
בדקו את עצמכם
נתונים #define INC_M(n) n + 1 ו-static inline int inc_i(int n) { return n + 1; }. מה מדפיס printf("%d %d", 3 * INC_M(2), 3 * inc_i(2));?
7 9. המאקרו מתרחב ל-3 * 2 + 1, כלומר 7, והפונקציה מחזירה 3, ואז 3 * 3 הוא 9.
למה בכותרת כותבים static inline ולא inline בלבד?
כי inline בלי static לא מייצר ב-C99 הגדרה חיצונית. אם המהדר בוחר שלא להטמיע, הקריאה נשארת והקישור נכשל ב-undefined reference. עם static כל קובץ .c מקבל עותק פנימי משלו.
char, מחרוזות, long ו-enum
char: ייצוג מספרי, חתום מול לא חתום ועטיפה
תלמיד שכותב char ch = getchar(); ואז בודק ch != EOF נופל לשתי מלכודות. כשהטיפוס char חתום, הבית 255 נחתך ל--1 ונראה בדיוק כמו סימן סוף הקלט, והלולאה נעצרת באמצע הקובץ. כשהוא לא חתום, EOF (שלילי, -1 ב-glibc) לעולם לא יתאים, והלולאה אינה נגמרת.
לכן getchar() מחזירה int: רק בו יש מקום גם לכל בית 0 עד 255 וגם לערך שלילי נפרד.
הבסיס לכל זה: char הוא שלם זעיר בגודל בית אחד (8 סיביות), ו-sizeof(char) הוא 1 בכל מימוש. בשפה יש שלושה טיפוסים נפרדים, char, signed char ו-unsigned char, וההחלטה אם char רגיל חתום נתונה למי שכתב את המהדר. ב-gcc על x86-64 הוא חתום (טווח מ--128 עד 127), ובמימוש של ARM Linux הוא לא חתום.
מה שנשמר בתא הוא קוד, לא צורה: printf("%c", 66) ו-printf("%d", 'B') מציגים את אותו מספר בשתי צורות, B ו-66. בטבלת ASCII הקוד של '0' הוא 48, של 'A' הוא 65 ושל 'a' הוא 97, ולכן 'a' - 'A' הוא 32 ו-'5' - '0' הוא המספר 5.
כשעושים x += k על משתנה char, החישוב עצמו מתבצע ב-int, ורק בשלב השמירה חזרה לבית אחד מתרחשת החיתוך. התוצאה תלויה בסימן:
- ב-
unsigned charחותכים מודולו 256: ההשמה של1000שומרת 232, ו-0 - 1נותן 255. - ב-
charחתום (התנהגות מוגדרת-מימוש, ו-gcc עוטף) מחסירים 256 מכל ערך שעבר את 127:150הופך ל--106,128ל--128 ו-180ל--76.
'q' נראה כבית בודד אבל הוא ערך int, ולכן sizeof('q') הוא 4 (ב-C++ התשובה 1). ואילו "q" היא מערך של שני בתים: התו עצמו ובית הסיום '\0'.תרחיש 13: חיתוך ערכים, קודי ASCII וגדלי ליטרלים
#include <stdio.h>
int main(void) {
char sc = 125;
sc += 8;
unsigned char uc = 250;
uc += 12;
char upper = 'd' - 32;
char neg = 240;
printf("%d %d %c %d %d\n", sc, uc, upper, '8' - '0', neg);
printf("%zu %zu %c %d\n", sizeof('Z'), sizeof("Z"), 68, 'D');
return 0;
}-123 6 D 8 -16
4 2 D 68sc: החיבור125 + 8 = 133מתבצע ב-int, ובחיתוך ל-charחתום מתקבל133 - 256 = -123.uc: הסכום250 + 12 = 262נחתך מודולו 256 ונשאר6.upper: הקוד של'd'(100) פחות 32 נותן 68, שהוא הקוד של'D'.neg: הערך 240 אינו נכנס ב-charחתום ועוטף ל-240 - 256 = -16.sizeof('Z')הוא 4 (int) בעודsizeof("Z")הוא 2 (תו +'\0').
מחרוזות: sizeof מול strlen ואחסון בזיכרון
הטעות הנפוצה ביותר במחרוזות היא לבלבל בין גודל ההקצאה בזיכרון לבין אורך הטקסט שבתוכה. בשפת C מחרוזת היא מערך תווים שמסתיים בבית אפס '\0', ושתי הפעולות מודדות דברים שונים לחלוטין:
| ביטוי | שלב החישוב | מה נספר בפועל |
|---|---|---|
sizeof(arr) | זמן קומפילציה | כל בתי המערך שהוקצו, כולל '\0' ותאים ריקים בסוף |
strlen(s) | זמן ריצה | תווים מתחילת המחרוזת ועד ה-'\0' הראשון, לא כולל אותו |
sizeof(ptr) | זמן קומפילציה | גודל המצביע עצמו (8 בתים ב-64 ביט), בלי קשר למחרוזת |
שימו לב גם להבדל בין מערך למצביע מבחינת עריכה: char str[] = "Test"; מקצה מערך הניתן לשינוי על המחסנית, ואילו char *str = "Test"; מצביע למחרוזת ליטרלית בזיכרון לקריאה בלבד, כך שכתיבה דרך המצביע (str[0] = 'B') היא התנהגות לא מוגדרת שלרוב תקריס את התוכנית.
באתחול חלקי של מערך תווים, כמו char fixed[9] = "ok"; או char list[4] = {'x', 'y'};, המהדר מאפס את כל התאים הנותרים. אם מחרוזת מכילה '\0' באמצע (למשל "hi\0bye"), פונקציות כמו strlen ו-%s ייעצרו בו ולא יגיעו לתווים שאחריו, אף ש-sizeof עדיין יכלול את כל 7 הבתים.
הפונקציה strcpy(dst, src) מעתיקה גם את בית הסיום, ו-strcat(dst, src) מתחילה להדביק בדיוק על גבי ה-'\0' הקיים של dst (בהנחה שיש מספיק מקום במערך היעד). דריסת תו קיים כמו b.code[3] = '_' מחליפה תו במקום בלי להאריך את המחרוזת, ומחרוזת בתוך struct נקטעת ב-'\0' שלה ואינה גולשת לשדה שאחריה.
תרחיש 14: מעקב אחרי מערכים, מצביע ומחרוזת בתוך struct
#include <stdio.h>
#include <string.h>
struct Badge {
char code[10];
int level;
};
int main(void) {
char raw[] = "hi\0bye";
char fixed[9] = "ok";
char list[4] = {'x', 'y'};
const char *ptr = "alpha";
printf("%zu %zu %zu %zu %zu %d\n",
sizeof raw, strlen(raw), sizeof fixed, strlen(fixed), sizeof ptr, list[3]);
struct Badge b = { "dev", 3 };
strcat(b.code, "-07");
b.code[3] = '_';
printf("%s %zu ", b.code, strlen(b.code));
b.code[4] = '\0';
printf("%s %zu %zu %d\n", b.code, strlen(b.code), sizeof b.code, b.level);
return 0;
}7 2 9 2 8 0
dev_07 6 dev_ 4 10 3| פקודה | תוכן b.code[0..6] | אורך לפי strlen |
|---|---|---|
| אתחול | d e v \0 \0 \0 \0 | 3 |
strcat(b.code, "-07") | d e v - 0 7 \0 | 6 |
b.code[3] = '_' | d e v _ 0 7 \0 | 6 |
b.code[4] = '\0' | d e v _ \0 7 \0 | 4 |
טעויות נפוצות
sizeof(s)על מערך תווים מחזיר את אורך המחרוזת. הוא מחזיר את מלוא גודל המערך בבתים, כולל'\0'ותאים ריקים.sizeof(p)עלchar *pמודד את אורך הטקסט. הוא מודד את גודל המצביע עצמו (8 בתים בארכיטקטורת 64 סיביות).strlenכוללת את'\0'בספירה או מדלגת מעליו. היא עוצרת בתו האפס הראשון ואינה סופרת אותו.charרגיל הוא תמיד לא חתום, ו-sizeof('A')הוא 1. ב-gcc על x86-64 הטיפוסcharחתום, וליטרל תו ב-C הואintבגודל 4 בתים.
בדקו את עצמכם
מה יודפס עבור char buf[12] = "Net\0Work"; printf("%s %zu %zu", buf, sizeof buf, strlen(buf));?
Net 12 3. ההדפסה והאורך עוצרים ב-'\0' שאחרי Net, ו-sizeof buf מחזיר 12.
ב-gcc על x86-64, מה יהיה הערך של c אחרי char c = 110; c += 30;?
-116. החיבור 110 + 30 = 140 חורג מ-127 ועוטף ל-140 - 256 = -116.
long, unsigned וגלישה אריתמטית
שורה כמו long area = 70000 * 70000; נראית תמימה, ובכל זאת התוצאה שגויה. שני הגורמים מימין הם int, ולכן הכפל מתבצע ב-int וגולש עוד לפני שההשמה בכלל מתחילה. כלל הברזל: רוחב החישוב נקבע לפי טיפוסי האופרנדים, ולא לפי המשתנה שמחכה לתוצאה.
כדי לדעת מה נכנס ב-long חייבים לדעת את הפלטפורמה, כי התקן מבטיח רק 32 סיביות לפחות (והשמות long, long int ו-signed long מייצגים אותו טיפוס). במודל LP64, הנהוג ב-Linux וב-macOS של 64 סיביות, הוא 8 בתים והערך LONG_MAX הוא 9223372036854775807. במודל LLP64 של Windows 64 סיביות, וגם במערכות 32 סיביות, הוא רק 4 בתים, ולכן שאלות מבחן מציינות את המערכת.
במפרטי printf משתמשים ב-%ld ל-long, ב-%lu ל-unsigned long וב-%lld ל-long long.
ב-LP64 מתקנים את הכפל על ידי הרחבת אופרנד אחד: (long)w * w, 70000L * 70000, או משתנה שהוא כבר long (long t = 3000000000L; t = t + t;). גם ליטרל עשרוני גדול, למשל 5000000000, מקבל שם בעצמו טיפוס long כי הוא לא נכנס ב-int.
גלישה היא גם עניין של סימן. בטיפוס חתום היא התנהגות לא מוגדרת (Undefined Behavior), אבל טיפוס unsigned אינו גולש בכלל: הוא עוטף מודולו 2^n. ב-32 סיביות 4294967290u + 10 מחזיר 4.
ב-64 סיביות העטיפה מתרחשת רק אם אחד האופרנדים הוא מהטיפוס הלא חתום: משתנה unsigned long long, או ליטרל עם הסיומת ull. כך 0ull - 2 הופך ל-18446744073709551614, ואילו 0 - 2 בליטרלים של int הוא פשוט -2 (והסיומת u לבדה נותנת רק טיפוס של 32 סיביות).
תרחיש 15: קידום אופרנדים ועטיפת unsigned (ב-64 סיביות)
#include <stdio.h>
int main(void) {
int n = 1500000000;
long long prod = (long long)n * 3;
long long base = 2500000000LL;
unsigned int u32 = 4294967292u;
u32 += 9;
unsigned long long u64 = 3;
u64 -= 7;
printf("%lld %lld %u %llu %zu\n", prod, base * 2, u32, u64, sizeof(long long));
return 0;
}4500000000 5000000000 5 18446744073709551612 8המרת (long long)n מקדמת את הכפל ל-64 סיביות ומונעת גלישה ב-int. המשתנה u32 עוטף מ-4294967301 מודולו 4294967296 ל-5, ו-u64 עוטף מ--4 ל-2^64 - 4. ב-Linux x86-64 תוצאה זהה תתקבל עם long ו-unsigned long בגודל 8 בתים.
טעויות נפוצות
- השמה למשתנה
longגורמת לכפל שמימין ל-=להתבצע ב-long. רק טיפוסי האופרנדים קובעים את רוחב החישוב; שניintיגלשו לפני ההשמה. longהוא תמיד 64 סיביות בכל מערכת 64 סיביות. ב-Linux/macOS (LP64) הוא 8 בתים, אך ב-Windows 64-bit (LLP64) הוא 4 בתים.- עטיפה של
unsignedהיא התנהגות לא מוגדרת. בניגוד לטיפוס חתום, פעולות עלunsignedמוגדרות היטב ועוטפות מודולו2^n. - אפשר להשתמש ב-
%dכדי להדפיסlong. ל-longמתאים%ld, ול-unsigned longמתאים%lu.
בדקו את עצמכם
מה ידפיס unsigned int u = 4294967200u; printf("%u", u + 150u); במערכת 64 סיביות?
54. הסכום 4294967350 עוטף מודולו 4294967296, והשארית היא 54.
enum וכללי המספור
הטיפוס enum נותן שמות לקבועים שלמים.
ברשימה enum { A, B = 9, C } מה שווה C? התשובה 10, וכאן נתפסים רוב מי שמתבלבלים: קבוע בלי ערך מפורש לוקח את הערך של השכן שלפניו ומוסיף 1. הוא אינו מחפש את המספר הגדול ביותר שכבר הופיע, והמקום הסידורי ברשימה לא משחק תפקיד.
- הקבוע הראשון, אם לא כתוב לו ערך, הוא 0.
- ערך מפורש יכול להיות כל ביטוי קבוע שלם: שלילי, קטן מהקודם, או מבוסס על קבועים קודמים באותו
enum(F2 = F0 << 2,HIGH = MID + 5). - שני שמות רשאים להחזיק באותו ערך (
DUP = NONE). - שני
enumבאותו תחום הכרה לא יכולים להגדיר את אותו שם, וגם אי אפשר לקרוא לקבוע כמו משתנה או פונקציה באותו תחום, כי כל השמות חולקים מרחב אחד.
כל קבוע הוא ערך int, ולכן מדפיסים אותו עם %d, ואין פונקציה מובנית שמחזירה את שמו. משתנה מסוג enum תופס ב-gcc על x86-64 בדיוק 4 בתים, בין אם הוגדרו שלושה קבועים ובין אם שלושים; רק הדגל -fshort-enums של המהדר משנה זאת.
הקבועים ידועים כבר בזמן הקומפילציה, ולכן מותר להשתמש בהם לאורך מערך ולתווית case. אסור להשתמש בהם בתנאי #if, כי ה-Preprocessor רץ לפני שהמהדר מכיר אותם. ועוד פרט: המהדר לא בודק טווח, כך שאפשר להשים במשתנה enum כל ערך int בלי שגיאה.
תרחיש 16: קפיצה שלילית, הזזה וכפילות ב-enum
#include <stdio.h>
enum Perm { NONE, READ = 4, WRITE, EXEC = READ - 7, GUEST, DUP = NONE, LAST };
enum Flag { F0 = 1, F2 = F0 << 2, F3 };
int main(void) {
int table[WRITE];
printf("%d %d %d %d %d %d %d\n", NONE, READ, WRITE, EXEC, GUEST, DUP, LAST);
printf("%zu %d %zu\n", sizeof table / sizeof table[0], F3, sizeof(enum Flag));
return 0;
}0 4 5 -3 -2 0 1
5 5 4| קבוע | כלל חישוב | ערך |
|---|---|---|
NONE | ראשון ברשימה ללא ערך | 0 |
READ | מפורש | 4 |
WRITE | READ + 1 | 5 |
EXEC | 4 - 7 | -3 |
GUEST | EXEC + 1 (לא 6) | -2 |
DUP | מפורש כשווה ל-NONE | 0 |
LAST | DUP + 1 | 1 |
F3 | F2 + 1 כש-F2 = 1 << 2 = 4 | 5 |
טעויות נפוצות
- מספור
enumמתחיל ב-1. הקבוע הראשון מקבל 0 כברירת מחדל. - אחרי ערך שלילי, הספירה חוזרת לערך המקסימלי שהופיע קודם. כל קבוע ללא ערך מפורש הוא תמיד הקודם ברשימה ועוד 1.
sizeofשלenumבן 3 קבועים הוא 1 או 3 בתים. ב-gcc רגיל הגודל הוא 4 בתים, בדומה ל-int.- אי אפשר לשייך אותו ערך לשני שמות שונים ב-
enum. כפילות ערכים מותרת לגמרי.
בדקו את עצמכם
מהם הערכים של L, M, N ו-P בהגדרה enum { K = -5, L, M = L * 2, N, P = K };?
L הוא -4, M הוא -8, N הוא -7, ו-P הוא -5.
XOR, switch ו-atoi
האופרטור ^: סיביות, קדימות והחלפה
שני פרטים שכדאי לסגור ראשונים: ^ הוא XOR על סיביות ולא חזקה (לחזקה יש את pow מ-<math.h>), ובתוצאה כל סיבית דולקת רק כשהסיביות של שני האופרנדים שונות. בכתיבה בינארית מצמידים את המספרים זה מעל זה ומשווים עמודה אחרי עמודה, כאשר & דורש ששתי הסיביות יהיו 1, | מסתפק באחת, ו-^ דורש בדיוק אחת:
13 = 1101 13 = 1101 13 = 1101
^ 7 = 0111 & 7 = 0111 | 7 = 0111
--------- --------- ---------
10 = 1010 5 = 0101 15 = 1111דמיינו מי שרוצה לבדוק אם שני מספרים שונים זה מזה וכותב if (a ^ b != 0). הקוד מתקמפל, אבל != נקשר חזק יותר מ-^, אז הוא מחושב כ-a ^ (b != 0): קודם מתקבל 0 או 1, ורק אז ה-XOR.
התוצאה נכונה רק במקרה: עם a = 5 ו-b = 5 מתקבל 5 ^ 1 = 4, שהוא אמת, אף שהמספרים זהים. הנוסחה הנכונה לבדיקת "שונים" עוטפת את ה-XOR בסוגריים: (a ^ b) != 0 (ואילו (a ^ b) == 0 בודקת שוויון). אותו כלל חל על ==.
| ביטוי (עם x = 0x6A) | תוצאה | מה לומדים ממנו |
|---|---|---|
x ^ x | 0 | ערך מול עצמו מתאפס |
x ^ 0 | 0x6a | אפס הוא האיבר הנייטרלי |
x ^ 0x35 ^ 0x35 | 0x6a | אותו מפתח פעמיים מבטל את עצמו |
x ^ (1u << 2) | 0x6e | הופך רק את סיבית 2 (כיבוי הופך לדלוק ולהפך) |
x ^ 0xFF | 0x95 | הופך את כל שמונה הסיביות הנמוכות |
בנוסף, הסדר בשרשרת של ^ אינו משנה את התוצאה, כי האופרטור חילופי וקיבוצי.
החלפה בלי משתנה זמני נעשית בשלוש שורות ^= (כמו ב-xor_swap שלמטה), ועובדת רק כשהמצביעים מפנים לשני משתנים שונים. כשמעבירים לה את אותה כתובת פעמיים, השורה הראשונה היא p ^= p והמשתנה מתאפס ל-0. בנוסף ^ מוגדר רק על שלמים, ועל float, double או מצביע התוכנית לא תתקמפל.
תרחיש 17: קדימות השוואה, החלפת XOR ומתג סיביות
#include <stdio.h>
void xor_swap(int *x, int *y) {
*x ^= *y;
*y ^= *x;
*x ^= *y;
}
int main(void) {
int p = 13, q = 7;
printf("%d %d ", p ^ q, p ^ q ^ q);
printf("%d %d\n", p ^ q == 7, (p ^ q) == 10);
xor_swap(&p, &q);
printf("%d %d\n", p, q);
xor_swap(&p, &p);
printf("%d %d\n", p, q);
unsigned reg = 0x25;
reg ^= 1u << 3;
printf("%#x ", reg);
reg ^= 0xFF;
printf("%#x\n", reg & 0xFF);
return 0;
}10 13 12 1
7 13
0 13
0x2d 0xd213 ^ 7הוא 10, וביצוע XOR נוסף עם 7 מחזיר 13.p ^ q == 7מתפרש כ-13 ^ (7 == 7), כלומר13 ^ 1 = 12(gcc מתריע כאן להוסיף סוגריים).xor_swap(&p, &p)מאפס אתpל-0 בגללx ^= x.0x25(0010 0101) עם היפוך סיבית 3 נותן0x2d, והיפוך 8 הסיביות הנמוכות נותן0xd2.
טעויות נפוצות
^הוא אופרטור חזקה. בשפת C אין אופרטור חזקה;2 ^ 3הוא XOR שערכו 1.a ^ b == cמשווה את תוצאת ה-XOR מולc. להשוואה יש קדימות גבוהה יותר, ולכן נדרשים סוגריים סביבa ^ b.- החלפת XOR בטוחה לכל זוג מצביעים. כאשר שני המצביעים מצביעים לאותו תא זיכרון, התא מתאפס ל-0.
^מתנהג כמו|. ההבדל מופיע כשהשתיים דולקות:1 ^ 1הוא 0 בעוד1 | 1הוא 1.x ^= kמציב אתkב-xאו מוסיף אותו. הוא מבצע XOR והופך רק את הסיביות שדולקות ב-k.
בדקו את עצמכם
מה ידפיס int a = 9, b = 4; printf("%d %d", a ^ b, a ^ b != 0);?
13 8. הראשון הוא 1001 ^ 0100 = 1101 (13). בשני, b != 0 מחושב קודם ל-1, ו-9 ^ 1 = 8.
switch, fall-through, break ו-continue
תחשבו על switch כעל מסדרון עם דלתות: התוויות case ו-default הן הדלתות שדרכן נכנסים, לא קירות שמפרידים בין חדרים. אחרי שנכנסים בדלת המתאימה, הביצוע ממשיך ישר דרך כל החדרים הבאים (fall-through), עד שנתקלים ב-break, ב-return, ב-continue של לולאה סביב, או בסוף ה-switch.
| מה כותבים | חוקי? | הסבר |
|---|---|---|
switch (x) עם int, char, long או enum | כן | ערך שלם, ואפשר גם ביטוי כמו st + 1 |
switch (d) עם double, מחרוזת או מצביע | לא | רק ערכים שלמים |
case 3:, case 'a':, case ST_B: או מאקרו שערכו קבוע | כן | קבוע שלם שידוע בזמן קומפילציה |
case N: כש-const int N = 3; | לא | ב-C זה אינו קבוע קומפילציה |
| שתי תוויות עם אותו ערך | לא | שגיאת קומפילציה |
defaultבכל מקום: מותר לשים אותו ראשון, באמצע או אחרון. הוא לא משפיע על היעד של קפיצה מוצלחת, אבל בליbreakהביצוע ממשיך ממנו אל התווית הבאה.- אין התאמה: בלי
defaultשום דבר לא רץ והתוכנית ממשיכה אחרי ה-switch, בלי שגיאה. כמה תוויות יכולות לחלוק גוף אחד (case '3': case '5':). - בתוך לולאה:
breakסוגר רק את ה-switchהפנימי ביותר והלולאה ממשיכה, ואילוcontinueמדלג על שאר גוף הלולאה אל הסיבוב הבא.
תרחיש 18: default באמצע, לולאה עם continue ו-switch מקונן
#include <stdio.h>
enum Step { ST_A = 1, ST_B, ST_C = 4 };
int eval_code(int k) {
int acc = 0;
switch (k) {
case 1:
acc += 3;
case 2:
acc += 40;
break;
default:
acc += 500;
case 4:
acc += 6000;
break;
case 5:
acc += 70000;
}
return acc;
}
int main(void) {
for (int i = 1; i <= 5; i++)
printf("%d ", eval_code(i));
printf("\n");
const char *log = "x3-y5-z";
int lets = 0, digs = 0, done = 0;
for (const char *c = log; *c; c++) {
switch (*c) {
case '-':
continue;
case '3':
case '5':
digs++;
break;
default:
lets++;
}
done++;
}
printf("%d %d %d\n", lets, digs, done);
enum Step st = ST_A;
switch (st + 1) {
case ST_B:
switch (done) {
case 1:
printf("one ");
break;
default:
printf("other ");
}
printf("mid ");
break;
default:
printf("end ");
}
printf("ok\n");
return 0;
}43 40 6500 6000 70000
3 2 5
other mid okk | קפיצה ראשונית | זרימת הביצוע | תוצאה |
|---|---|---|---|
| 1 | case 1 | מוסיף 3, גולש ל-case 2, מוסיף 40, break | 43 |
| 2 | case 2 | מוסיף 40, break | 40 |
| 3 | default | אין case 3: מוסיף 500, גולש ל-case 4, מוסיף 6000, break | 6500 |
| 4 | case 4 | מדלג על default, מוסיף 6000, break | 6000 |
| 5 | case 5 | מוסיף 70000 ומסיים | 70000 |
בלולאה על "x3-y5-z", שני תווי המקף מפעילים continue ומדלגים על done++, בעוד הספרות והאותיות מגיעות אליו. בחלק המקונן, st + 1 שווה ל-ST_B, ה-switch הפנימי נכנס ל-default שלו (other), ואז מודפס mid וה-break החיצוני מדלג על end.
טעויות נפוצות
- כל תווית
caseעוצרת את הביצוע לפני התווית הבאה. ללאbreak, הביצוע גולש דרך התוויות הבאות. defaultחייב להופיע בסוף, ואינו גולש לתוויות שאחריו. הוא יכול להופיע בכל מקום, ואם אין בוbreakהוא גולש מטה כמו כל תווית.breakבתוךswitchיוצא גם מהלולאה המקיפה אותו. הוא יוצא רק מה-switchהפנימי ביותר.- אם אין תווית מתאימה ואין
default, מתרחשת שגיאת ריצה. התוכנית פשוט ממשיכה אחרי ה-switch.
בדקו את עצמכם
מה יהיה ערכו של total בסוף: int total = 0; for (int step = 0; step < 3; step++) switch (step) { case 0: total += 4; default: total += 3; case 2: total += 5; }?
25. עבור step = 0 נוספים 4 + 3 + 5 = 12; עבור step = 1 נכנסים ב-default ונוספים 3 + 5 = 8; עבור step = 2 נוספים 5.
atoi: המרת מחרוזת לשלם ומגבלותיה
הפונקציה int atoi(const char *s) מ-<stdlib.h> מיועדת להמרת מחרוזת למספר שלם, אך חשוב להכיר קודם מה היא אינה עושה: היא אינה מעגלת מספרים עשרוניים, אינה מפרשת בסיס הקסדצימלי (0x...), ואינה מדווחת שגיאות.
- מדלגת על כל הרווחים שבתחילת המחרוזת.
- אם מופיע
+או-אחד, זוכרת אותו כסימן. - צוברת ספרות עשרוניות ברצף, עד התו הראשון שאינו ספרה, ואז עוצרת בלי הודעה.
- אם לא נקלטה אף ספרה, התוצאה
0.
היא קוראת מספר שלם ולא ספרה בודדת: atoi("507") הוא 507 (לא 5 ולא קוד ה-ASCII של '5'), והתוצאה היא int רגיל, כך ש-atoi("99") + 1 הוא 100. למבחן כדאי לזכור: atoi("5.99") הוא 5, atoi("0xFF") הוא 0, atoi("8 3") הוא 8, ו-atoi("xyz1") ו-atoi("") הם 0.
החולשה של atoi היא שאין לה ערוץ שגיאה: הקלט "0" והקלט "abc" נותנים אותו ערך, ומספר שלא נכנס ב-int מוביל להתנהגות לא מוגדרת. בקוד שחשוב לו לאמת קלט משתמשים ב-strtol(s, &end, base), שמחזירה את מקום העצירה ומסמנת חריגה ב-errno (ויש גם atol ו-atof ל-long ול-double). וכדי להפוך ספרת תו אחת למספר פשוט כותבים c - '0'.
תרחיש 19: בדיקת שבעה קלטים שונים ב-atoi
#include <stdio.h>
#include <stdlib.h>
int main(void) {
const char *cases[] = { " -14", "7.89", "0x4B", "+25m", "4 9", "none", "" };
int sum_all = 0;
for (int idx = 0; idx < 7; idx++) {
int num = atoi(cases[idx]);
printf("%d ", num);
sum_all += num;
}
printf("| %d\n", sum_all);
return 0;
}-14 7 0 25 4 0 0 | 22| קלט | התנהגות | ערך |
|---|---|---|
" -14" | מדלגת על רווחים, קוראת סימן וספרות | -14 |
"7.89" | נעצרת בנקודה ללא עיגול | 7 |
"0x4B" | קוראת 0, נעצרת ב-x | 0 |
"+25m" | קוראת +25, נעצרת ב-m | 25 |
"4 9" | נעצרת ברווח שאחרי 4 | 4 |
"none" / "" | ללא ספרה בהתחלה | 0 |
טעויות נפוצות
atoi("7.89")מעגלת ל-8. היא נעצרת בנקודה ומחזירה 7.atoi("0x4B")מחזירה 75. אין תמיכה בהקסדצימלי; היא קוראת 0 ועוצרת ב-x.- קלט לא תקין מחזיר -1 או מפיל את התוכנית. היא מחזירה 0 בשקט בלי לדווח על שגיאה.
- רווח בתחילת המחרוזת עוצר את הפענוח. רווחים מובילים מדולגים; רק רווח שמופיע אחרי הספרות עוצר.
בדקו את עצמכם
מהו הסכום atoi(" -8xy") + atoi("4.95") + atoi("0x5") + atoi("+15")?
11. החישוב הוא -8 + 4 + 0 + 15 = 11.
struct ו-union
struct: הגדרה, אתחול, העתקה ומערכים
הבדל אחד מכריע קובע אם פונקציה תשנה את הנתונים של הקורא: כשמעבירים struct בודד לפונקציה, הוא מועתק כולו לפי ערך (כולל מערך קבוע שמוטמע בתוכו), ואילו כשמעבירים מערך של מבנים, המערך דועך למצביע ולכן הפונקציה משנה את האיברים המקוריים.
הגדרת טיפוס נראית כך: struct Point { int x; int y; };, והשם המלא שלו הוא struct Point, אלא אם עטפו אותו ב-typedef. אל שדה פונים בנקודה כשיש משתנה (s.op(a, b) אם השדה הוא מצביע לפונקציה) ובחץ כשיש מצביע: p->x שקול ל-(*p).x. מבנה יכול להכיל גם מצביע לעצמו (struct Node *next;), אבל == בין שני מבנים לא קיים, ויש להשוות שדה אחר שדה.
- לפי סדר: ב-
{ 3, 10 }השדה הראשון מקבל 3 והשני 10. מה שלא נכתב מתאפס:{ 7 }משאיר את השני 0, ו-{ 0 }מנקה את כל המבנה. - לפי שם (C99):
{ .id = 12, .samples = { 4 }, .tag = label }מתעלם מהסדר, ושדות ותאי מערך שלא הוזכרו מתאפסים. - מערך מבנים: כל זוג סוגריים פנימי הוא איבר אחד, ב-
{ {3, 10}, {7}, {2, 12} }לאיבר האמצעי ישlat7 ו-lon0.
כל פעולה של העברה לפונקציה, החזרה ממנה או השמה כמו t2 = t1 מעתיקה את כל בתי המבנה. שדה שהוא מצביע מעתיק רק את הכתובת, וכך כתיבה דרך המצביע בעותק משנה זיכרון שגם המקור רואה.
תרחיש 20: מבנה לפי ערך, מצביע פנימי ומערך מבנים
#include <stdio.h>
struct Telemetry {
int id;
int samples[2];
char *tag;
};
struct Waypoint {
int lat;
int lon;
};
void edit_copy(struct Telemetry t) {
t.id = 88;
t.samples[1] = 77;
t.tag[0] = 'Z';
}
void shift_path(struct Waypoint path[], int len) {
for (int k = 0; k < len; k++) {
path[k].lat += 5 * k;
path[k].lon -= 2 * k;
}
}
void shift_single(struct Waypoint w) {
w.lat = -1;
}
int main(void) {
char label[] = "gps";
struct Telemetry t1 = { .id = 12, .samples = { 4 }, .tag = label };
struct Telemetry t2 = t1;
t2.id = 20;
edit_copy(t1);
printf("%d %d %d %d %s\n", t1.id, t1.samples[0], t1.samples[1], t2.id, label);
struct Waypoint route[3] = { {3, 10}, {7}, {2, 12} };
shift_path(route, 3);
shift_single(route[0]);
printf("%d %d %d %d\n", route[1].lat, route[1].lon, route[2].lat + route[2].lon, route[0].lat);
return 0;
}12 4 0 20 Zps
12 -2 20 3edit_copy(t1)משנה רק את העותק שלidו-samples[1], אךt.tagפונה למערךlabelהמקורי ומשנה אותו ל-"Zps".shift_pathמקבלת מצביע למערךroute: איבר 1 הופך ל-(12, -2)ואיבר 2 ל-(12, 8)שסכומו 20.shift_single(route[0])מקבלת עותק של איבר יחיד, ולכןroute[0].latנשאר 3.
העתקה רדודה מול העתקה עמוקה ב-Heap
נניח שבתוך מבנה יש מצביע לבלוק מה-Heap, והמתכנת כותב shallow = src. זו העתקה רדודה (shallow copy): int count מועתק לעותק עצמאי, אבל שני המצביעים מחזיקים כתובת זהה, ולכן shallow.arr == src.arr נותן 1. אם יקראו ל-free על שניהם, זה double free.
תוצאת הדבר: מי שכותב לבלוק דרך מבנה אחד, השני רואה את השינוי, ויש לשחרר בלוק אחד בלבד. העתקה עמוקה (deep copy) פותרת זאת: מקצים בלוק חדש לעותק, מעתיקים לתוכו את הערכים (בלולאה או עם memcpy), וכל מבנה משחרר את הבלוק שלו.
תרחיש 21: העתקה רדודה ועמוקה על מערך ב-Heap
#include <stdio.h>
#include <stdlib.h>
struct PacketBuf {
int *arr;
int count;
};
int main(void) {
struct PacketBuf src;
src.count = 2;
src.arr = malloc(src.count * sizeof(int));
if (src.arr == NULL) return 1;
src.arr[0] = 10;
src.arr[1] = 20;
struct PacketBuf shallow = src;
struct PacketBuf deep = src;
deep.arr = malloc(deep.count * sizeof(int));
if (deep.arr == NULL) {
free(src.arr);
return 1;
}
for (int i = 0; i < deep.count; i++) deep.arr[i] = src.arr[i];
shallow.arr[1] = 95;
deep.arr[0] = 42;
src.count = 99;
printf("%d %d %d %d %d %d\n",
src.arr[0], src.arr[1], shallow.count, deep.arr[0], deep.arr[1], shallow.arr == src.arr);
free(src.arr);
free(deep.arr);
return 0;
}10 95 2 42 20 1src.arr ---+
+--> [ 10 | 95 ] (shared block)
shallow.arr ---+
deep.arr ---------> [ 42 | 20 ] (independent block)הכתיבה shallow.arr[1] = 95 משנה את הבלוק המשותף, בעוד deep מחזיק בלוק פרטי משלו ו-shallow.count נשאר 2. בסיום מתבצעים שני free בדיוק: אחד עבור src.arr ואחד עבור deep.arr.
טעויות נפוצות
- השמה
b = aמשכפלת גם את הזיכרון הדינמי שהמצביעים במבנה מצביעים אליו. מועתקת הכתובת בלבד, ולכן שני המבנים חולקים אותו בלוק ב-Heap. b = aהופך אתbלכינוי זהה שלaבכל השדות. שדות רגילים ב-bהם עותק נפרד שאינו מושפע משינויים ב-a.- יש לקרוא ל-
freeעבור כל עותק של המבנה. משחררים כל הקצאתmallocפעם אחת בלבד כדי למנועdouble free.
בדקו את עצמכם
במבנה struct Item { char *title; };, מקצים ל-a.title את "pen", מבצעים b = a; b.title[2] = 'g';. מה ידפיס printf("%s %d", a.title, a.title == b.title);?
peg 1. שני המבנים מצביעים לאותה מחרוזת ב-Heap.
יישור בזיכרון (Alignment) ובתי ריפוד (Padding)
מדוע sizeof של מבנה גדול לעתים מסכום השדות? ב-x86-64 כל טיפוס חייב להתחיל בהיסט שמתחלק ביישור (alignment) שלו: 1 ל-char, 2 ל-short, 4 ל-int ול-float, ו-8 ל-double, ל-long (ב-LP64) ולמצביע. המהדר ממלא את הרווחים בבתי ריפוד (padding), בין השדות ובסוף המבנה.
הדרך הבטוחה לחשב היא לעבור שדה אחרי שדה ולרשום לעצמכם איפה נגמר המקום התפוס. כך נראה המעקב עבור struct T { char a; double b; short c; }:
| שדה | יישור | סוף הנתונים עד כה | ההיסט שנבחר |
|---|---|---|---|
a (char) | 1 | 0 | 0 |
b (double) | 8 | 1 | 8, הכפולה הקרובה של 8 (7 בתי ריפוד) |
c (short) | 2 | 16 | 16 |
| סיום | 8 (המרבי) | 18 | מעגלים ל-24 (6 בתי ריפוד) |
כלומר שני כללים: כל שדה זז קדימה עד הכפולה הקרובה של היישור שלו, ובסוף המבנה כולו מעוגל לכפולה של היישור הגדול ביותר, כדי שגם איברי מערך יישארו מיושרים.
offsetof(type, member) מ-<stddef.h> מחזיר היסט בפועל, וסידור שדות מהיישור הגדול לקטן מצמצם ריפוד. שדה שהוא union או struct נושא את היישור של החבר המיושר ביותר שבתוכו. למשל אם union Num { char digits[3]; double v; } בגודל 8 וביישור 8, אז ב-struct Rec { int id; union Num n; } השדה n יושב בהיסט 8 (אחרי 4 בתי ריפוד) והגודל הכולל הוא 16.
תרחיש 22: השוואת חמישה סידורי שדות והיסטים
#include <stdio.h>
#include <stddef.h>
struct S1 { char a; short b; int c; };
struct S2 { char a; int b; char c; };
struct S3 { int b; char a; char c; };
struct S4 { short a; double d; char c; };
struct S5 { double d; short a; char c; };
int main(void) {
printf("%zu %zu %zu %zu %zu\n",
sizeof(struct S1), sizeof(struct S2),
sizeof(struct S3), sizeof(struct S4), sizeof(struct S5));
printf("%zu %zu %zu\n",
offsetof(struct S1, b), offsetof(struct S2, c), offsetof(struct S4, d));
return 0;
}8 12 8 24 16
2 8 8| מבנה | היסטים | סוף נתונים | יישור מרבי | sizeof |
|---|---|---|---|---|
S1 | a: 0, b: 2, c: 4 | 8 | 4 | 8 |
S2 | a: 0, b: 4, c: 8 | 9 | 4 | 12 |
S3 | b: 0, a: 4, c: 5 | 6 | 4 | 8 |
S4 | a: 0, d: 8, c: 16 | 17 | 8 | 24 |
S5 | d: 0, a: 8, c: 10 | 11 | 8 | 16 |
המבנים S2 ו-S3 מכילים בדיוק אותם שדות אך סידור מחדש חוסך 4 בתים, וכך S5 חוסך 8 בתים מול S4.
טעויות נפוצות
sizeofשלstructהוא סכום השדות בלבד. המהדר מוסיף בתי ריפוד בין שדות ובסוף המבנה.- סדר הכרזת השדות אינו משפיע על גודל המבנה. שינוי הסדר משנה את הריפוד הפנימי והסופי.
- אין ריפוד אחרי השדה האחרון במבנה. הגודל הסופי מתעגל למעלה לכפולה של היישור המרבי.
בדקו את עצמכם
ב-x86-64, מהו גודל struct { char a; long long b; short c; } ומהו ההיסט של c?
גודל 24, היסט 16. a בהיסט 0 (7 בתי ריפוד), b בהיסט 8, c בהיסט 16, והסיום מתעגל לכפולה של 8.
#pragma pack, bit-fields ומערך גמיש
לעתים נדרשת שליטה ישירה על פריסת הזיכרון מעבר לכללי היישור הרגילים, ולכך משמשים שלושה כלים:
#include <stdio.h>
#pragma pack(push, 1)
struct FrameP { char tag; int len; short crc; };
#pragma pack(pop)
struct Frame { char tag; int len; short crc; };
struct Mode { unsigned level : 3; unsigned flag : 1; };
int main(void) {
struct Mode m = { 0, 1 };
m.level = 11;
printf("%zu %zu %u %u %zu\n", sizeof(struct Frame), sizeof(struct FrameP),
m.level, m.flag, sizeof(struct Mode));
return 0;
}12 7 3 1 4Frame רגיל תופס 12 בתים: 3 בתי ריפוד אחרי tag ועוד 2 בסוף. בין #pragma pack(push, 1) ל-#pragma pack(pop) (הרחבה של המהדר) השדות צמודים, ו-FrameP הוא 1 + 4 + 2 = 7.
החיסכון בזיכרון בא במחיר: ב-x86 גישה לשדה לא מיושר נסבלת אבל איטית יותר, ובכמה מעבדים אחרים היא גורמת לשגיאת חומרה. מבנים שמוגדרים אחרי ה-pop חוזרים להיות מרופדים.
בשדה הסיביות level : 3 נכנסים רק הערכים 0..7. ההשמה m.level = 11 נחתכת מודולו 8 ומשאירה 3 (המהדר אף מזהיר על כך). שני השדות יחד תופסים 4 סיביות, אבל gcc שומר אותם ביחידת unsigned int שלמה, ולכן sizeof(struct Mode) הוא 4 ולא 1.
הכלי השלישי מתמודד עם נתונים באורך לא ידוע מראש: מערך גמיש (flexible array member, C99), שהוא השדה האחרון בלי מספר בסוגריים. נקצה כותרת קצרה יחד עם הטקסט שאחריה בהקצאה אחת:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
struct Note {
short len;
char text[];
};
int main(void) {
const char *src = "alert";
struct Note *n = malloc(sizeof(struct Note) + strlen(src) + 1);
if (n == NULL) return 1;
n->len = (short)strlen(src);
strcpy(n->text, src);
printf("%zu %d %s\n", sizeof(struct Note), n->len, n->text);
free(n);
return 0;
}2 5 alertsizeof(struct Note) מודד רק את len (2 בתים), כי המערך הגמיש אינו נספר. מה שמאפשר לו להכיל טקסט הוא הבתים הנוספים שביקשנו ב-malloc.
תרחיש 23: אריזה ללא ריפוד, bit-fields ומערך גמיש
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#pragma pack(push, 1)
struct WireHdr { short a; int b; char c; };
#pragma pack(pop)
struct RegBits {
unsigned r1 : 2;
unsigned r2 : 3;
unsigned r3 : 2;
};
struct LogEntry {
int id;
char msg[];
};
int main(void) {
struct RegBits rb = { 3, 6, 1 };
rb.r1 += 2;
rb.r2 += 4;
rb.r3 = rb.r1 - 3;
printf("%zu %u %u %u %zu\n",
sizeof(struct WireHdr), (unsigned)rb.r1, (unsigned)rb.r2, (unsigned)rb.r3, sizeof(struct RegBits));
struct LogEntry *e = malloc(sizeof(struct LogEntry) + 5);
if (e == NULL) return 1;
e->id = 4;
strcpy(e->msg, "boot");
printf("%zu %s %c\n", sizeof(struct LogEntry), e->msg, e->msg[e->id - 1]);
free(e);
return 0;
}7 1 2 2 4
4 boot tWireHdrתופס2 + 4 + 1 = 7בתים בלבד ללא ריפוד.rb.r1התחיל ב-3:3 + 2 = 5, וב-2 סיביות נשמר5 mod 4 = 1(לכןrb.r1הוא 1 כשמחשבים אתrb.r3).rb.r2:6 + 4 = 10, וב-3 סיביות נשמר10 mod 8 = 2.rb.r3:1 - 3 = -2, וב-2 סיביות נשמר-2 mod 4 = 2.sizeof(struct RegBits)הוא 4 בתים (אף שיש בו 7 סיביות בלבד), ו-sizeof(struct LogEntry)סופר רק אתid(4 בתים).
union וסדר בתים (Little Endian)
נסו להריץ את האיחוד הבא, שמחזיק int ומערך של 6 תווים באותו מקום, ולכתוב דרך חבר אחד ולקרוא דרך האחר:
#include <stdio.h>
union Pair { int whole; char tag[6]; };
int main(void) {
union Pair p;
p.whole = 1000;
printf("%zu %d ", sizeof(union Pair), p.whole);
p.tag[0] = 0;
printf("%d\n", p.whole);
return 0;
}8 1000 768הגודל 8 נובע מכך שהחבר הגדול הוא 6 בתים, ויישור ה-int הוא 4, ולכן מעגלים 6 לכפולה של 4. הכתיבה ל-tag[0] מחקה את הבית הנמוך של 1000 (0x3E8), ונשאר 0x300, כלומר 768. הכלל בשורה אחת: כל חברי ה-union מתחילים באותה כתובת, הגודל הוא של הגדול שבהם מעוגל ליישור המרבי, וכתיבה לאחד דורסת את האחרים.
קריאה מחבר אחר מותרת ב-C, אבל לא מתבצעת המרה: אותם בתים מפורשים מחדש, והתוצאה תלויה בייצוג בזיכרון. כך 0.5f שנכתב ל-float ונקרא כ-unsigned int נותן את דפוס IEEE 754, 0x3F000000 שהוא 1056964608, ולא 0. (ההדפסה %c של int שערכו 65 נותנת A בגלל %c עצמו, ללא קשר ל-union.)
c.u = 0x11223344;
address: +0 +1 +2 +3
bytes: 44 33 22 11 (Little Endian on x86-64)
index: b[0] b[1] b[2] b[3]בפירוק הבתים של 0x11223344 מתברר איפה כל בית יושב: במעבדי x86 ו-x86-64 (Little Endian) הבית הנמוך 0x44 נמצא בכתובת הנמוכה, b[0], ובמכונת Big Endian היה ההפך. לפירוק מספר עשרוני: 772 הוא 0x0304, ולכן b[0] = 0x04 ו-b[1] = 0x03.
באתחול של union, { 12 } מציב ערך בחבר הראשון ו-{ 0 } מאפס את כל הבתים. אם אחד החברים הוא struct { int row; int col; } pos;, השדות row ו-col נפרדים זה מזה, והמבנה כולו הוא שחופף לחברים האחרים.
תרחיש 24: סדר בתים, גדלים ופירוש מחדש ב-union
#include <stdio.h>
union Cell { unsigned int u; unsigned char b[4]; };
union U1 { char s[11]; int n; };
union U2 { char s[5]; short k; };
union U3 { char s[9]; double d; };
union F32 { float f; unsigned int bits; };
union Combo { struct { int x; int y; } pt; long long raw; };
int main(void) {
union Cell c;
c.u = 0x11223344;
printf("%02X %02X %x\n", c.b[0], c.b[3], c.b[1]);
c.u = 772;
printf("%d %d\n", c.b[0], c.b[1]);
printf("%zu %zu %zu %zu\n",
sizeof(union Cell), sizeof(union U1), sizeof(union U2), sizeof(union U3));
union Cell init = { 12 };
printf("%u\n", init.u);
union F32 fp;
fp.bits = 9;
fp.f = 0.5f;
printf("%u\n", fp.bits);
union Combo cb;
cb.pt.x = 3;
cb.pt.y = 8;
printf("%d\n", cb.pt.x + cb.pt.y);
union Cell zero = { 0 };
zero.b[0] = 'K';
printf("%u\n", zero.u);
return 0;
}44 11 33
4 3
4 12 6 16
12
1056964608
11
75הגודל של U2 הוא 5 מעוגל לכפולה של יישור short (2), כלומר 6. ב-zero, כל הבתים אופסו תחילה ואז הבית הנמוך b[0] קיבל 'K' (75), ולכן zero.u שווה 75.
טעויות נפוצות
- גודל
unionהוא סכום שדותיו, או תמיד בדיוק גודל השדה הגדול ביותר. הוא גודל השדה הגדול ביותר מעוגל למעלה לכפולה של היישור המרבי. - כל השדות ב-
unionשומרים על הערך שלהם במקביל. הם חולקים אותו זיכרון, וכתיבה לאחד דורסת את האחרים. - קריאת שדה אחר מבצעת המרת טיפוס (למשל
0.5fהופך ל-0). הבתים נקראים מחדש לפי הטיפוס החדש ללא המרה. b[0]הוא הבית העליון של המספר. ב-x86 ו-x86-64 (Little Endian) האינדקס 0 מחזיק את הבית הנמוך.
בדקו את עצמכם
ב-x86-64, לאחר union { int x; unsigned char b[4]; } u; u.x = 0x4B4C4D4E;, מה ידפיס printf("%c%c", u.b[0], u.b[3]);?
NK. הבית הנמוך 0x4E הוא 'N' ב-b[0], והבית העליון 0x4B הוא 'K' ב-b[3].
מהו sizeof(union { char tag[14]; int id; })?
16. הגודל 14 מתעגל למעלה לכפולה של יישור int (4).
מצביעים לפונקציות ומוסכמות קריאה
הצהרה וקריאה דרך int (*f)(int, int)
מי שכותב int *handler(int, int); ומאמין שיצר מצביע טועה: הסוגריים של רשימת הפרמטרים נצמדים לשם חזק יותר מהכוכבית, ולכן זו הצהרה של פונקציה רגילה שמחזירה int *. כדי שהכוכבית תיצמד לשם צריך לעטוף אותה: int (*handler)(int, int); היא משתנה מצביע שמחזיק כתובת של קוד.
קוראים הצהרה כזו מהשם החוצה. ב-double (*conv)(const char *); השם conv הוא מצביע (הכוכבית בתוך הסוגריים), לפונקציה (הסוגריים שאחריו), שמקבלת const char * ומחזירה double (הטיפוס שבתחילת השורה).
| כתיב | מה הוא אומר |
|---|---|
fn = calc_diff; ו-fn = &calc_diff; | זהים. שם של פונקציה שמופיע כערך הופך אוטומטית לכתובת שלה, ולכן ה-& אופציונלי. |
fn(9, 4) ו-(*fn)(9, 4) | זהים. שתיהן מריצות את הפונקציה שהמצביע מחזיק, עם הארגומנטים שניתנו, כמו קריאה ישירה. |
sizeof fn | שמונה בתים בארכיטקטורת x86-64, והגודל אינו תלוי בחתימה של הפונקציה. |
int (**pf)(int, int) = &fn; | מצביע למצביע: *pf הוא fn עצמו, ולכן (*pf)(7, 1) מפעיל את הפונקציה. |
מצביע לפונקציה הוא רק מספר, והמהדר לא יודע מה נמצא בכתובת. אם המצביע לא אותחל, אם הוא NULL, או אם הוא מוצהר בטיפוס שלא מתאים לפונקציה האמיתית, הקפיצה אליו היא התנהגות לא מוגדרת. מקרה NULL נעצר בלינוקס לרוב עם SIGSEGV, כי הכתובת 0 אינה ממופה.
תרחיש 25: ארבע דרכים להפעיל את אותו מצביע
#include <stdio.h>
int calc_diff(int left, int right) { return left - right; }
int main(void) {
int (*fn)(int, int) = calc_diff;
int (*fn2)(int, int) = &calc_diff;
int (**pf)(int, int) = &fn;
printf("%d %d %d %d\n", fn(9, 4), (*fn2)(12, 5), (*pf)(7, 1), (**pf)(3, 8));
return 0;
}5 7 6 -5הפונקציה היא תמיד calc_diff; מה שמשתנה הוא רק הדרך להגיע אליה. החישובים הם 9 - 4, 12 - 5, 7 - 1 ו-3 - 8, ולכן הפלט 5 7 6 -5, והאחרון שלילי.
טבלאות פונקציות, typedef, מבנים ו-callback
בקוד אמיתי מצביעים לפונקציות כמעט לא עומדים לבד, אלא בתוך אחד מחמישה מבנים. אפשר לזהות כל אחד לפי הצורה שלו:
| מבנה | כתיב | לשם מה |
|---|---|---|
| שם לטיפוס | typedef int (*calc_fn)(int, int); ואז calc_fn op; | קיצור: במקום לחזור על התחביר המסורבל בכל הצהרה, כותבים שם אחד. |
פרמטר (callback) | int chain(calc_fn op, int x, int y); | הפונקציה הכללית מקבלת מבחוץ את הפעולה שתריץ, כמו פונקציית ההשוואה של qsort. |
שדה ב-struct | struct Worker { int (*exec)(int, int); }; ואז w.exec(14, 6) | מצמיד התנהגות לנתונים ומאפשר פולימורפיזם בסיסי ב-C: אותו כתיב קריאה, פעולה שונה לכל אובייקט. |
| מערך | int (*table[3])(int, int) = { plus, minus, times }; ואז table[i](a, b) | טבלת ניתוב (dispatch table): הפונקציה נבחרת לפי אינדקס, במקום switch ארוך. |
| פונקציה שמחזירה מצביע | int *(*sp)(int) = store_inc; ואז *sp(12) | הקריאה רצה לפני הכוכבית, ולכן התוצאה היא הערך שנמצא בכתובת שהפונקציה החזירה. |
אפשר לספור את איברי הטבלה בלי מספר קבוע: sizeof table / sizeof table[0] נותן את מספר האיברים (כאן 3), כי כל איבר הוא מצביע ו-sizeof table[0] הוא 8 בתים.
בלולאה שמפעילה את הטבלה, פתחו טבלת מעקב עם שורה לכל סיבוב: האינדקס, שם הפונקציה, הארגומנטים והתוצאה. שימו לב ש-acc מוזן חזרה, כלומר התוצאה של כל סיבוב היא הארגומנט הראשון בסיבוב שאחריו.
תרחיש 26: טבלת ניתוב, typedef ופונקציית עיבוד
#include <stdio.h>
int plus(int left, int right) { return left + right; }
int minus(int left, int right) { return left - right; }
int times(int left, int right) { return left * right; }
typedef int (*calc_fn)(int, int);
int chain(calc_fn op, int x, int y) {
return op(op(x, y), y);
}
struct Worker {
int (*exec)(int, int);
};
int *store_inc(int v) {
static int slot;
slot = v + 5;
return &slot;
}
int triple_val(int val) { return val * 3; }
int inc(int val) { return val + 1; }
void apply_all(int *arr, int len, int (*fn)(int)) {
for (int idx = 0; idx < len; idx++) {
arr[idx] = fn(arr[idx]);
}
}
int main(void) {
int (*table[3])(int, int) = { plus, minus, times };
int acc = 6;
int idx = 0;
while (idx < 3) {
acc = table[idx](acc, idx + 2);
idx++;
}
printf("%d %zu %zu\n", acc, sizeof table / sizeof table[0], sizeof table[0]);
printf("%d %d\n", chain(minus, 10, 3), chain(times, 2, 4));
int (**pp)(int, int) = &table[2];
struct Worker w;
w.exec = plus;
int *(*sp)(int) = store_inc;
printf("%d %d %d\n", (*pp)(3, 9), w.exec(14, 6), *sp(12));
int nums[3] = { 2, 4, 6 };
apply_all(nums, 3, triple_val);
apply_all(nums, 3, inc);
printf("%d %d %d\n", nums[0], nums[1], nums[2]);
return 0;
}20 3 8
4 32
27 20 17
7 13 19אינדקס idx | הפונקציה בטבלה | הקריאה בפועל | הערך החדש של acc |
|---|---|---|---|
0 | plus | plus(6, 2) | 8 |
1 | minus | minus(8, 3) | 5 |
2 | times | times(5, 4) | 20 |
chain(minus, 10, 3)היאminus(minus(10, 3), 3), כלומרminus(7, 3) = 4; עםtimesמתקבלtimes(times(2, 4), 4) = 32.ppמחזיק את הכתובת שלtable[2], שהיאtimes, ולכן(*pp)(3, 9)מחזיר27.w.execמפעיל אתplus(14, 6)ומחזיר20.store_inc(12)מחזירה כתובת של משתנהstaticשמכיל17, והיא נשארת תקפה גם אחרי שהפונקציה מסתיימת.- ב-
numsהתוצאה תלויה בסדר: אחריtriple_valהערכים הם{6, 12, 18}, ורק אזincמוסיפה אחד לכל תא. בסדר הפוך היו מתקבלים ערכים אחרים.
טעויות נפוצות
table[1]הוא האיבר הראשון בטבלת הפונקציות. האינדקסים מתחילים ב-0: הראשון הואtable[0](כאןplus), ו-table[1]הואminus.- ההצהרה
int *f(int, int);יוצרת מצביע לפונקציה. בלי הסוגריים סביב*fזו הצהרה של פונקציה בשםfשמחזירהint *. - מצביע לפונקציה מחזיק כתובת של נתונים. הכתובת שבו היא של קוד, כלומר תחילת הפונקציה בקטע
.text, ולא של משתנה. - בכל הפעלה חייבים לכתוב את הצורות המלאות,
&fnו-(*fn)(a, b). אין חובה: שם הפונקציה הופך לכתובת מעצמו, והצורות המקוצרות זהות לארוכות. - בלולאה על טבלת פונקציות כל פונקציה מקבלת את הערך שהיה למשתנה לפני הלולאה. אם התוצאה נשמרת חזרה באותו משתנה, כל סיבוב עובד על התוצאה של הקודם.
בדקו את עצמכם
בטבלה table מהתרחיש (plus, minus, times), מה ערכו של acc בסוף: int acc = 3; for (int k = 0; k < 3; k++) acc = table[k](acc, acc);?
0. plus(3, 3) = 6, אחר כך minus(6, 6) = 0, ולבסוף times(0, 0) = 0.
מה מחזירה הקריאה chain(minus, 20, 6) עבור chain מהתרחיש?
8. chain מפעילה את הפעולה פעמיים: minus(20, 6) = 14, ואז minus(14, 6) = 8.
מוסכמות קריאה: __cdecl, __stdcall ו-__fastcall
כדי להבין מוסכמת קריאה (calling convention), כדאי ללוות קריאה אחת מההתחלה ועד הסוף. נניח שבמצב 32 סיביות תחת cdecl נקראת הפונקציה mix(a, b): הקוראת דוחפת למחסנית קודם את b ואחר כך את a ומבצעת call, והנקראת מחזירה את התוצאה ב-EAX עם ret. שני הארגומנטים עדיין יושבים על המחסנית, והקוראת מסלקת אותם בעצמה עם add esp, 8.
כל מה שהופיע בסיפור הוא חלק מהחוזה: איפה הארגומנטים, מי מסלק אותם, באיזה רגיסטר חוזרת התוצאה, ואילו רגיסטרים הנקראת חייבת להחזיר כפי שמצאה. ב-stdcall משתנה רק פרט אחד: הנקראת מסיימת ב-ret 8, והקוראת לא נוגעת במחסנית.
אל תחפשו את __cdecl, __stdcall ו-__fastcall בתקן של C. הם נכנסו לשפה כתוספי מהדר של Microsoft לתוכניות x86 בנות 32 סיביות, ומהדרים אחרים, כמו gcc, מציעים להם מקבילות בתחביר __attribute__.
| מוסכמה | איפה הארגומנטים | מי מסלקת אותם | עוד |
|---|---|---|---|
cdecl | במחסנית, מהאחרון אל הראשון | הקוראת, אחרי החזרה (add esp, N) | ברירת המחדל של C ב-32 סיביות. אפשרית גם לפונקציות עם מספר ארגומנטים משתנה, כמו printf. התוצאה ב-EAX. |
stdcall | במחסנית, מהאחרון אל הראשון | הנקראת, בהוראה ret N | משמשת ב-Win32 API. אינה מתאימה לארגומנטים משתנים. |
fastcall | שני הראשונים ב-ECX וב-EDX, האחרים במחסנית | הנקראת | עשויה לחסוך גישות לזיכרון בפונקציות קטנות, אבל היתרון אינו מובטח. |
System V x86-64 | שישה ראשונים: RDI, RSI, RDX, RCX, R8, R9 | הקוראת | Linux ו-macOS. התוצאה ב-RAX. |
Windows x64 | ארבעה ראשונים: RCX, RDX, R8, R9 | הקוראת | הקוראת שומרת לנקראת 32 בתים במחסנית (shadow space). |
ב-64 סיביות הוויכוח נסגר: כל פלטפורמה קבעה מוסכמה אחת (System V ב-Linux וב-macOS, Windows x64 ב-Windows). לכן __cdecl ו-__fastcall לא משנות שם דבר, ו-MSVC פשוט מתעלם מהן.
המוסכמה גם מחלקת את הרגיסטרים בין הצדדים. ב-32 סיביות הנקראת רשאית לשנות את EAX, ECX ו-EDX כרצונה, אבל את EBX, ESI, EDI ו-EBP עליה להחזיר בדיוק כפי שקיבלה.
הסכנה מתעוררת כשהצדדים לא מסכימים. אם הקוראת מניחה מוסכמה אחת והנקראת מממשת אחרת, למשל כשמצביע לפונקציה מוצהר בטיפוס שגוי, הארגומנטים נקראים ממקום לא נכון והמחסנית מסולקת בגודל לא נכון. התוצאה היא מחסנית פגומה והתנהגות לא מוגדרת.
טעויות נפוצות
__fastcallהיא חלק מתקן C וגם תמיד מהירה יותר. זו הרחבה של מהדרים ל-32 סיביות, והחיסכון שלה תלוי בקוד ובמיטוב.- ב-
cdeclמי שמסלקת את הארגומנטים מהמחסנית היא הנקראת. ב-cdeclהקוראת מסלקת (add esp, N); הנקראת מסלקת רק ב-stdcallוב-fastcall. - אפשר לכתוב פונקציה כמו
printfכ-stdcall. רק הקוראת יודעת כמה ארגומנטים שלחה, ולכן ניקוי בידי הנקראת (ret N) דורש מספר ארגומנטים קבוע. - ב-
x86-64הוספה של__stdcallאו__fastcallמשנה את הקוד שנוצר. ב-64 סיביות יש מוסכמה אחת לכל פלטפורמה, והמילים האלה לא משנות כלום.
המחסנית (Stack), רקורסיה ו-static
מסגרת מחסנית (Stack frame) וגבולותיה
דמיינו ערימת צלחות: את הצלחת שהונחה אחרונה מרימים ראשונה. מחסנית הקריאות (call stack) עובדת כך, לפי עקרון LIFO: הפונקציה שנקראה אחרונה היא הראשונה שמסיימת.
בכל קריאה נבנית מסגרת (stack frame) חדשה. בתוכה נשמרת כתובת החזרה, יושבים המשתנים המקומיים, ומוצאים מקום גם הפרמטרים שלא נכנסו לרגיסטרים. כשהפונקציה מסיימת המסגרת מוסרת, והמעבד ממשיך מהשורה שאחרי הקריאה.
מכיוון שלכל קריאה יש מסגרת משלה, גם פונקציה שקוראת לעצמה אינה חולקת משתנים עם עצמה: ה-n של הקריאה הפנימית הוא תא אחר מה-n של החיצונית.
| מה רואים | מה קורה ולמה |
|---|---|
התוכנית נעצרת עם segmentation fault בעומק רקורסיה | גלישת מחסנית (stack overflow). המחסנית מוגבלת בגודלה, בדרך כלל ל-8 MB בתהליכון הראשי ב-Linux, ורקורסיה בלי תנאי עצירה או מערך מקומי ענק ממלאים אותה. |
| ערך מוזר במשתנה מקומי שעדיין לא נכתב | משתנה מקומי אינו מאותחל לבד. קריאה שלו לפני השמה היא התנהגות לא מוגדרת. |
ההודעה stack smashing detected | כתיבה מעבר לסוף מערך מקומי עלולה לדרוס את כתובת החזרה שנמצאת באותה מסגרת (stack smashing). הידור עם -fstack-protector מגלה זאת ועוצר את התוכנית. |
| יצירה ושחרור של מסגרת מהירים מאוד | ב-x86 וב-x86-64 המחסנית צומחת לכיוון כתובות נמוכות, ו-RSP מצביע לראשה. יצירת מסגרת היא הזזה של RSP, ושחרורה הוא הזזה חזרה. |
מעקב אחרי רקורסיה בשיטת המדרגות
הטעות הנפוצה בעקיבה אחרי רקורסיה היא לנהל הכול בראש ולערבב בין הקריאות. במקום זה כתבו כל קריאה בשורה נפרדת שמוזחת עמוק יותר מקודמתה, ולצד כל שורה את הערכים המקומיים של אותה קריאה.
| מה | הכלל |
|---|---|
| פקודה שלפני הקריאה הרקורסיבית | רצה בדרך למטה, בסדר הקריאות: קודם החיצונית, אחר כך הפנימיות. |
| פקודה שאחרי הקריאה הרקורסיבית | רצה בדרך חזרה למעלה, בסדר הפוך, בזמן שהמסגרות מתפרקות: קודם העמוקה ביותר. |
| ערך מוחזר | נבנה מלמטה למעלה: הקריאה העמוקה מסיימת ראשונה ומוסרת ערך לקריאה שמעליה. |
משתנה גלובלי או static | קיים בעותק אחד לכל הקריאות. כשהקריאה החיצונית מגיעה ל-return, הוא כבר מכיל את כל מה שהקריאות הפנימיות עשו. |
תרחיש 27: שלושה דפוסים של קריאות רקורסיביות
#include <stdio.h>
int climb(int n) {
int step = n * 3;
int sub = 0;
if (n > 0) {
sub = climb(n - 1);
}
printf("%d ", step);
return sub + step;
}
void echo_steps(int k) {
if (k <= 0) {
return;
}
printf("[%d]", k);
echo_steps(k - 1);
printf("(%d)", k);
}
int visits = 0;
int tally(int n) {
int own = n;
visits++;
if (n > 0) {
tally(n - 1);
}
return visits * 10 + own;
}
int main(void) {
int res = climb(3);
printf("| %d\n", res);
echo_steps(3);
printf("\n");
int out = tally(2);
printf("%d %d\n", out, visits);
return 0;
}0 3 6 9 | 18
[3][2][1](1)(2)(3)
32 3climb(3) step=9 -> calls climb(2)
climb(2) step=6 -> calls climb(1)
climb(1) step=3 -> calls climb(0)
climb(0) step=0 prints 0, returns 0
prints 3, returns 0 + 3 = 3
prints 6, returns 3 + 6 = 9
prints 9, returns 9 + 9 = 18climbמדפיסה רק אחרי שהקריאה הפנימית חזרה, ולכן הפלט0 3 6 9מתחיל במסגרת העמוקה ביותר ומסתיים בחיצונית.echo_stepsמדפיסה פעמיים:[k]בדרך למטה ו-(k)בדרך חזרה, ולכן מתקבל[3][2][1](1)(2)(3). כש-kמגיע ל-0 היא חוזרת מיד בלי להדפיס.- ב-
tallyלכל קריאה ישownמשלה, אבלvisitsאחד לכולן. עד שהקריאה החיצונית מגיעה ל-return, שלוש הקריאות כבר הגדילו אותו ל-3, ולכן התוצאה3 * 10 + 2 = 32.
static, משתנים גלובליים והחזרת כתובת מקומית
כדי לדעת מה מותר להחזיר מפונקציה, שאלו איפה המשתנה חי ומתי הוא נוצר:
| סוג משתנה | איפה הוא חי | מתי הוא נוצר | הכתובת שלו אחרי שהפונקציה חזרה |
|---|---|---|---|
| מקומי רגיל | במחסנית, במסגרת של הקריאה | בכל כניסה לפונקציה, מחדש | מצביע תלוי (dangling pointer): המסגרת הוסרה, והשימוש בו הוא התנהגות לא מוגדרת. gcc בדרך כלל מזהיר. |
מקומי עם static | באזור הנתונים: .data כשהערך ההתחלתי שונה מאפס, .bss כשהוא אפס או חסר | פעם אחת, לפני תחילת הריצה | תקפה לאורך כל הריצה, ולכן אפשר להחזיר אותה (גם של מערך static). |
בלוק מ-malloc | ב-Heap | בקריאה ל-malloc | תקפה עד free, ולכן אפשר להחזיר גם מבנה שמחזיק מצביע לבלוק כזה. |
הצירוף 'פעם אחת' חשוב: שורת האתחול של משתנה static אינה פקודה שרצה בכל כניסה. לכן static int s = 0; לא מאפסת את s בכל קריאה, והערך נשמר מקריאה לקריאה.
תרחיש 28: מונה static מול מונה מקומי רגיל
#include <stdio.h>
int tick(void) {
static int persist = 0;
int temp = 0;
persist++;
temp++;
return persist * 10 + temp;
}
int main(void) {
tick();
tick();
printf("%d\n", tick());
return 0;
}31בכל קריאה persist מתקדם (1, 2, 3) כי הוא חי בין הקריאות, ואילו temp נולד מחדש ב-0 ומגיע ל-1 בכל פעם. לכן הקריאה השלישית מחזירה 3 * 10 + 1.
טעויות נפוצות
- משתנה מקומי רגיל נשאר עם ערכו האחרון לקריאה הבאה. הוא נוצר מחדש בכל קריאה, במסגרת חדשה. רק משתנה
staticזוכר. - השורה
static int s = 0;בתוך פונקציה מתבצעת שוב בכל כניסה. האתחול מתרחש פעם אחת, לפני תחילת הריצה. - משתנה מקומי רגיל שלא אותחל מתחיל ב-0. רק משתנים גלובליים ו-
staticמתאפסים. ערכו של מקומי רגיל אינו מוגדר, וקריאתו לפני השמה היא התנהגות לא מוגדרת. - בקריאות רקורסיביות כולן כותבות לאותו משתנה מקומי. לכל קריאה יש מסגרת ועותק משלה של המשתנים המקומיים.
printfשבא אחרי הקריאה הרקורסיבית מדפיס לפי סדר הקריאות. הוא רץ רק אחרי שהקריאה הפנימית חזרה, ולכן בסדר הפוך: מהעמוקה אל החיצונית.- אסור להחזיר כתובת של משתנה
static. הוא חי עד סוף התוכנית, ולכן הכתובת תקפה. הבעיה קיימת רק במשתנה מקומי רגיל.
בדקו את עצמכם
מה מדפיסה הקריאה h(2) עבור void h(int n) { if (n > 0) { printf("%d", n); h(n - 1); printf("%d", n * 10); } }?
211020. בדרך למטה מודפסים 2 ו-1, h(0) חוזרת מיד, ובדרך חזרה מודפסים 10 (של n = 1) ואחר כך 20 (של n = 2).
מה יודפס: int next(void) { static int c = 5; c += 2; return c; } ואז int a = next(); int b = next(); printf("%d %d", a, b);?
7 9. c מאותחל ל-5 פעם אחת בלבד ושומר את ערכו: הקריאה הראשונה מחזירה 7 והשנייה 9.
ה-Heap ומשפחת malloc
הקצאה דינמית עם malloc
שתי טעויות פותחות את רוב השאלות על malloc. הראשונה היא malloc(10) כשהכוונה לעשרה int: זה עשרה בתים בלבד, ואילו המערך צריך 40. השנייה היא לחשוב ש-sizeof(p) של מצביע שקיבל בלוק נותן את גודל הבלוק: התוצאה היא 8, גודל המצביע עצמו.
ה-Heap (הערימה) הוא האזור של ההקצאה הדינמית. בלוק שהוקצה בו נשאר בחיים עד שמבצעים עליו free, בלי קשר לפונקציה שהקצתה אותו, והדרך היחידה להגיע אליו היא דרך מצביע.
- הגודל:
int *p = malloc(n * sizeof *p);היא הצורה המומלצת, כי הגודל נגזר מהטיפוס שהמצביע מצביע עליו. הבלוק לא נושא את האורך שלו, ולכן התוכנית חייבת לשמור אותו במשתנה משלה. - החתימה: הפונקציה מקבלת מספר בתים ומחזירה
void *, כתובת של בלוק שגודלו לפחות כמבוקש, אוNULLכשאין מספיק זיכרון (void *malloc(size_t size), בכותרת<stdlib.h>). לכן בודקים את התוצאה לפני כל שימוש. - התוכן: הבלוק החדש לא מאופס. קריאה מתא לפני שנכתב אליו נותנת ערך לא ידוע, אבל אם הקוד כותב לכל תא לפני שהוא קורא אותו, הפלט לא תלוי בתוכן ההתחלתי.
- המרה (cast): ב-C אפשר לכתוב
p = malloc(...)בלי להמיר, והמרה כמו(int *)malloc(...)מותרת אך מיותרת. ב-C++ ההמרה חובה.
איפוס עם calloc ושינוי גודל עם realloc
calloc(n, size) מקצה מקום ל-n איברים בני size בתים ומאפסת את כל הבתים. לכן קריאה מתא שלא נכתב אחרי calloc מוגדרת ומחזירה 0, בניגוד ל-malloc.
ומה אם המערך שהקצאתם התברר כקטן מדי? realloc(p, new_size) משנה את גודל הבלוק שאליו p מצביע, ויש לה חמישה כללים שהמבחנים אוהבים לבדוק:
- כישלון: כש-
reallocמחזירהNULL, הבלוק הישן נשאר תקף. לכןp = realloc(p, n);מסוכן: בכישלון הוא דורס את המצביע היחיד לבלוק ויוצר דליפה. הפתרון הוא לקבל את התוצאה במשתנה זמני ולבדוק אותו לפני ההשמה. - העברה: אם אין מקום להתרחב במקום, נבחר מקום חדש: ההקצאה נעשית שם, התוכן הישן מועתק אליו (עד הקטן מבין שני הגדלים), והבלוק הישן חוזר ל-Heap.
- הכתובת: התוצאה היא הכתובת התקפה מעכשיו. המצביע הישן עלול להצביע לזיכרון ששוחרר, ולכן לא משתמשים בו.
- התאים החדשים: בהגדלה הם אינם מאותחלים, גם אם הבלוק המקורי הוקצה ב-
calloc. - מקרה קצה:
realloc(NULL, n)שקולה ל-malloc(n).
תרחיש 29: עבודה עם calloc, realloc והחזרת מבנה מהפונקציה
#include <stdio.h>
#include <stdlib.h>
int main(void) {
int *buf = calloc(3, sizeof *buf);
if (buf == NULL) return 1;
buf[2] = 9;
buf[0] += 5;
printf("%d %d %d\n", buf[0], buf[1], buf[2]);
int *bigger = realloc(buf, 5 * sizeof *bigger);
if (bigger == NULL) {
free(buf);
return 1;
}
buf = bigger;
buf[3] = 11;
buf[4] = 15;
int acc = 0;
for (int idx = 0; idx < 5; idx++) {
acc += buf[idx];
}
printf("%d\n", acc);
free(buf);
buf = NULL;
free(buf);
printf("done\n");
return 0;
}5 0 9
40
doneאחרי calloc כל שלושת התאים הם 0, ולכן buf[0] += 5 נותן 5 ו-buf[1] נשאר 0. realloc משמרת את 5, 0, 9, התוכנית ממלאת את שני התאים החדשים לפני שהיא קוראת אותם, והסכום הוא 5 + 0 + 9 + 11 + 15 = 40. ה-free(buf) האחרון, אחרי buf = NULL, הוא free(NULL) ואינו עושה כלום.
#include <stdio.h>
#include <stdlib.h>
struct Packet {
int *items;
int len;
};
struct Packet create_packet(int n) {
struct Packet pk;
pk.len = n;
pk.items = malloc(n * sizeof(int));
if (pk.items != NULL) {
for (int idx = 0; idx < n; idx++) {
pk.items[idx] = (idx + 1) * 4;
}
}
return pk;
}
int *expand_arr(int *ptr, int old_len, int new_len) {
int *tmp = realloc(ptr, new_len * sizeof *tmp);
if (tmp == NULL) return NULL;
for (int idx = old_len; idx < new_len; idx++) {
tmp[idx] = (idx + 1) * 10;
}
return tmp;
}
int main(void) {
struct Packet pk = create_packet(3);
if (pk.items == NULL) return 1;
int acc = 0;
for (int idx = 0; idx < pk.len; idx++) {
acc += pk.items[idx];
}
printf("%d\n", acc);
int *next = expand_arr(pk.items, 3, 5);
if (next == NULL) {
free(pk.items);
return 1;
}
pk.items = next;
printf("%d %d %d\n", pk.items[2], pk.items[3], pk.items[4]);
free(pk.items);
return 0;
}24
12 40 50create_packet מחזירה עותק של המבנה, אבל העותק מחזיק את אותה כתובת ב-Heap, והבלוק עצמו לא נעלם כשהפונקציה מסתיימת: 4 + 8 + 12 = 24. expand_arr מרחיבה את הבלוק ומשאירה את 12 בתא 2.
שחרור עם free, דליפת זיכרון ושגיאות חמורות
דליפה מתחילה מכתובת שאבדה. בלוק דולף כשהמצביע האחרון אליו נדרס או יוצא מהתחום (scope) לפני שנקרא free, ואז אי אפשר עוד לשחרר אותו. לכן גם p = malloc(...) על מצביע שעדיין מחזיק בלוק לא משחררת ולא מוחקת את הישן: הוא נשאר תפוס, בלי אף אחד שיכול להגיע אליו.
מבחינת התוצאות, דליפה לא משנה את הפלט ולא מפילה תוכנית קצרה, כי כשהתהליך מסתיים מערכת ההפעלה מקבלת בחזרה את כל הזיכרון שלו. בתוכנית שרצה זמן ארוך הצריכה רק גדלה. דליפות, שחרורים כפולים וגישות אחרי free מוצאים בזמן ריצה עם valgrind או עם הדגל -fsanitize=address.
הפונקציה free(p) מיועדת לבלוק שהגיע מ-malloc, מ-calloc או מ-realloc, והיא מחזירה אותו ל-Heap. הטבלה מסכמת מה אפשר ומה אסור לעשות איתה:
| מה עושים | מה קורה |
|---|---|
קוראים ל-free פעמיים על אותה כתובת שאינה NULL (double free) | התנהגות לא מוגדרת. ב-glibc התוכנית נעצרת לרוב עם ההודעה free(): double free detected. |
ניגשים לבלוק דרך p אחרי free(p) (use after free) | התנהגות לא מוגדרת, גם אם נדמה שהערך הישן עדיין שם. |
מעבירים ל-free כתובת שלא התקבלה מהקצאה: מצביע שלא אותחל, כתובת במחסנית או נקודה באמצע בלוק | התנהגות לא מוגדרת. |
מעבירים ל-free את NULL | הקריאה מוגדרת ואינה עושה דבר. בזכות זה אחרי p = NULL; שחרור נוסף של p אינו מזיק. |
מסתכלים על הערך של p מיד אחרי free(p) | הערך לא השתנה: p ממשיך להחזיק את הכתובת הישנה והוא מצביע תלוי. כדי למנוע שימוש בו כותבים p = NULL; מיד אחרי. |
תרחיש 30: שמירת הבלוק הקודם לפני הקצאה חדשה
#include <stdio.h>
#include <stdlib.h>
int main(void) {
int *first = malloc(2 * sizeof *first);
if (first == NULL) return 1;
first[0] = 3;
first[1] = 8;
int *saved = first;
first = malloc(2 * sizeof *first);
if (first == NULL) {
free(saved);
return 1;
}
first[0] = saved[0] * 10;
first[1] = saved[1] * 10;
printf("%d %d %d\n", first[0] + first[1], saved[0] + saved[1], first == saved);
free(saved);
free(first);
return 0;
}110 11 0הכתובת של הבלוק הראשון נשמרת ב-saved לפני ש-first מקבל בלוק חדש, ולכן שני הבלוקים נגישים ושניהם משוחררים בסוף. first == saved הוא 0 כי אלה שני בלוקים שונים. אילו השורה int *saved = first; הייתה חסרה, הבלוק הראשון היה דולף ברגע ההשמה השנייה.
טעויות נפוצות
free(p)מציבהNULLב-p.freeמקבלת עותק של הכתובת ולא יכולה לשנות אתp. כדי לאפס צריךp = NULL;בנפרד.- קריאה ל-
freeעל מצביע שלא אותחל בטוחה. זו התנהגות לא מוגדרת. רקNULLבטוח. mallocמחזירה זיכרון מאופס. רקcallocמאפסת;mallocמשאירה את הבתים כפי שהיו.free(NULL)היא שגיאת ריצה. התקן מגדיר אותה כפעולה שאינה עושה כלום.- אחרי הקצאה חדשה למצביע, הבלוק הקודם משתחרר לבד. הבלוק הקודם נשאר תפוס ודולף.
- בלוק שדלף נשאר תפוס גם אחרי שהתהליך נגמר. עם סיום התהליך מערכת ההפעלה מחזירה לעצמה את כל הזיכרון שלו.
- אחרי
reallocאפשר להמשיך להשתמש במצביע הישן. ייתכן שהבלוק הועבר לכתובת אחרת והישן כבר שוחרר.
בדקו את עצמכם
האם יש בעיה בקוד char *s = malloc(8); char *t = s; free(s); free(t);?
כן. s ו-t מחזיקים את אותה כתובת, ולכן זה שחרור כפול של אותו בלוק: התנהגות לא מוגדרת.
מה יודפס: int *v = calloc(6, sizeof *v); v[1] = 4; v[4] = 9; printf("%d", v[0] + v[1] + v[4] + v[5]);?
13. calloc מאפסת את כל התאים, ולכן הסכום הוא 0 + 4 + 9 + 0.
מה קורה כשכותבים p = malloc(16); פעמיים ברצף על אותו מצביע, בלי free ביניהן?
הבלוק הראשון נשאר תפוס ואין אליו מצביע: זו דליפה. התוכנית לא נעצרת בשגיאה והפלט לא משתנה.
מערך דו-ממדי דינמי ורשימה מקושרת
בשני המבנים האלה סדר הפעולות הוא העיקר. במערך דו-ממדי דינמי (int **) כל שורה הוקצתה בנפרד, והמצביע הראשי מחזיק רק את הכתובות שלהן. לכן משחררים את השורות בלולאה ורק בסוף את int ** עצמו: אם משחררים אותו קודם, אי אפשר עוד לקרוא את כתובות השורות.
ברשימה מקושרת כל חוליה מכילה מצביע לחוליה הבאה, מהטיפוס של עצמה (struct Item *next;). חוליה לא יכולה להכיל עותק של עצמה בתוכה, כי גודלה היה אינסופי, אבל מצביע לעצמה מותר.
- הכנסה לראש:
node->next = head; head = node;. החוליה האחרונה שהוכנסה היא הראשונה ברשימה, ולכן הסדר מתהפך. - הסרת הראש: שומרים את הראש במצביע זמני, מזיזים את
headלחוליה הבאה, ורק אז קוראים ל-freeעל הזמני. אם משחררים קודם, הכתובת של החוליה הבאה הולכת לאיבוד.
תרחיש 31: מטריצה דינמית ורשימה מקושרת ב-Heap
#include <stdio.h>
#include <stdlib.h>
struct Item {
int num;
struct Item *next;
};
int main(void) {
int **mat = malloc(3 * sizeof *mat);
if (mat == NULL) return 1;
for (int r = 0; r < 3; r++) {
mat[r] = malloc(2 * sizeof **mat);
if (mat[r] == NULL) return 1;
for (int c = 0; c < 2; c++) {
mat[r][c] = r * 5 + c + 1;
}
}
int total = 0;
for (int r = 0; r < 3; r++) {
for (int c = 0; c < 2; c++) {
total += mat[r][c];
}
}
for (int r = 0; r < 3; r++) {
free(mat[r]);
}
free(mat);
printf("%d\n", total);
struct Item *head = NULL;
for (int i = 1; i <= 4; i++) {
struct Item *node = malloc(sizeof *node);
if (node == NULL) return 1;
node->num = i * 3;
node->next = head;
head = node;
}
printf("%d ", head->num);
struct Item *victim = head;
head = head->next;
free(victim);
int len = 0, sum = 0;
for (struct Item *cur = head; cur != NULL; cur = cur->next) {
len++;
sum += cur->num;
}
printf("%d %d\n", len, sum);
while (head != NULL) {
struct Item *nxt = head->next;
free(head);
head = nxt;
}
return 0;
}39
12 3 18השורות מחזיקות 1 2, 6 7 ו-11 12, ולכן הסכום הוא 39. הכנסה לראש בונה את הרשימה 12 -> 9 -> 6 -> 3. מסירים את 12, ובשלוש החוליות שנותרו len הוא 3 ו-sum הוא 9 + 6 + 3 = 18.
בנייה: Object file, Linker, Makefile ו-System call
ארבעת שלבי הבנייה של gcc
הפקודה gcc main.c -o prog נראית כמו פעולה אחת, אבל מאחוריה ארבע תחנות. אפשר לעצור אחרי כל אחת מהן בעזרת דגל ולבדוק מה נוצר:
| דגל | התחנה שהוא עוצר אחריה | מה מקבלים |
|---|---|---|
-E | עיבוד מקדים: מטפל ב-#include, מרחיב מאקרו, משאיר רק את השורות שהתנאים מתירים ומסיר הערות | טקסט C מורחב ב-stdout (או קובץ .i עם -save-temps) |
-S | קומפילציה: מתרגמת את קוד ה-C לשפת Assembly | הקובץ main.s |
-c | הרכבה: הופכת את ה-Assembly לקוד מכונה | קובץ האובייקט main.o |
| אין דגל | קישור: ה-Linker מאחד קבצי אובייקט וספריות | קובץ הרצה: prog, או a.out כשאין -o |
שתי טעויות נפוצות במבחן: gcc -c main.c נעצר לפני הקישור, ולכן main.o אינו קובץ הרצה; ו-gcc -E main.c אינו מדפיס Assembly ואינו קוד מכונה, אלא את טקסט ה-C אחרי העיבוד המקדים.
קובץ אובייקט והכלי nm
קובץ אובייקט הוא מה שנשאר אחרי שקובץ מקור אחד עבר קומפילציה והרכבה, אבל לפני הקישור: .o ב-Linux ו-.obj ב-MSVC. ב-Linux הוא בפורמט ELF מסוג relocatable, כלומר כתובות שעדיין ניתן להזיז.
אי אפשר להריץ אותו משתי סיבות: הכתובות בקוד עדיין לא סופיות, והפניות לפונקציות ולמשתנים שבקבצים אחרים טרם נפתרו. הרשומות שעוזרות ל-Linker לתקן אותן נקראות relocation.
| חלק בקובץ | מה בו |
|---|---|
.text | קוד המכונה של הפונקציות. |
.data | משתנים מאותחלים בערך שאינו אפס. |
.rodata | נתונים לקריאה בלבד, כמו מחרוזות ליטרליות. |
.bss | משתנים מאופסים או בלי ערך. בקובץ נשמר רק הגודל שלהם, והם לא תופסים בו מקום. |
| טבלת סמלים | השמות של הפונקציות והמשתנים שהקובץ מגדיר או מבקש. |
| רשומות relocation | הוראות ל-Linker אילו מקומות בקוד לתקן כשהכתובות ייקבעו. |
הכלי nm מדפיס את טבלת הסמלים, ואות אחת לצד כל סמל מגלה לאיזה חלק הוא שייך. אות גדולה מסמנת סמל גלובלי, ואות קטנה (t, d, b) סמל מקומי לקובץ, כלומר static ברמת הקובץ:
אות ב-nm | מה היא אומרת | דוגמה בקוד |
|---|---|---|
T / t | הפונקציה מוגדרת בקובץ הזה, בקטע .text | int run(void) { ... } (T) או static int helper(void) (t) |
D / d | משתנה שהערך ההתחלתי שלו אינו אפס, בקטע .data | int mode = 4; (D) או static int seed = 7; (d) |
B / b | משתנה בלי ערך התחלתי או עם אפס, בקטע .bss | int flag; int count = 0; (B) או static int zero = 0; (b) |
R | נתון לקריאה בלבד, בקטע .rodata | const int LIMIT = 10; |
U | שם שהקובץ משתמש בו אבל מוגדר בקובץ אחר (undefined) | extern int ext_val; |
בפלט האמיתי של nm העמודה הראשונה היא היסט שמשתנה בין מהדרים, ולעיתים מופיעות גם שורות עם שמות של קטעים; מה שחשוב הוא האות. כמה כלים משלימים: objdump -d מפרק את קוד המכונה ל-Assembly, readelf -S מציג את רשימת הקטעים, ו-strip מסיר את טבלת הסמלים. ספרייה סטטית (.a) היא ארכיון שאוסף כמה קבצי אובייקט.
ה-Linker: extern, static ושגיאות קישור
כל קובץ מקור מתקמפל לבד, ולכן הוא רק מניח שהשמות החיצוניים שלו קיימים איפשהו. ה-Linker (ב-Linux ld, ש-gcc מפעיל עבורכם) הוא זה שבסוף מוצא לכל שם כזה את ההגדרה האמיתית, מצרף את הקטעים של כל הקבצים לתמונה אחת וקובע כתובות סופיות.
| כתיב | מה זה | מה קורה בקישור |
|---|---|---|
extern int global_factor; | הצהרה | לא נוצר משתנה. ההצהרה רק מודיעה שההגדרה נמצאת בקובץ אחר, וה-Linker מחבר אליה את ההפניה. |
int global_factor = 2; בקובץ אחד | הגדרה | זה המשתנה היחיד. כל הקבצים שמשתמשים בשם מחוברים אליו, ולכן כולם חולקים אותו. |
static int seq = 3; ברמת הקובץ | הגדרה עם קישור פנימי (internal linkage) | נראית רק בקובץ שלה. שני קבצים יכולים להחזיק seq נפרד כל אחד, בלי התנגשות. |
ושתי השגיאות שה-Linker מדווח עליהן מספרות איפה הסדר נשבר:
undefined reference to 'foo': מישהו משתמש ב-fooוהוא הוצהר, אבל בין הקבצים והספריות שבשורת הפקודה אין לו הגדרה.multiple definition of 'foo': אותו שם מוגדר בליstaticביותר מקובץ אחד. מ-gcc 10גםint x;בלי ערך התחלתי בשני קבצים נחשב כך.
תרחיש 32: static פרטי בשני קבצים ו-extern בקובץ שלישי
/* mod1.c */
static int seq = 3;
int step_one(void) { seq += 5; return seq; }
/* mod2.c */
static int seq = 30;
int step_two(void) { return ++seq; }
/* store.c */
int global_factor = 2;
void scale_up(void) { global_factor *= 4; }
/* app.c */
#include <stdio.h>
int step_one(void);
int step_two(void);
extern int global_factor;
void scale_up(void);
int main(void) {
int a = step_one();
int b = step_two();
int c = step_one();
scale_up();
scale_up();
printf("%d %d %d %d\n", a, b, c, global_factor);
return 0;
}8 31 13 32ארבעת הקבצים מקושרים יחד (gcc mod1.c mod2.c store.c app.c -o app) בלי שום התנגשות. step_one מקדמת את ה-seq של mod1.c ל-8 ואחר כך ל-13, step_two מקדמת את ה-seq של mod2.c ל-31, ו-global_factor מוכפל פעמיים ל-32. אילו seq היה מוגדר בלי static בשני הקבצים, ה-Linker היה עוצר עם multiple definition of 'seq'.
ספריות, סדר בשורת הפקודה והדגל -Wl
נתחיל בכישלון שחוזר בכל כיתה: הספרייה קיימת, ה--L. נכון, ובכל זאת הקישור נופל עם undefined reference. הסיבה היא הסדר בשורת הפקודה.
/* scale.c: the library */
int scale_up(int v) { return v * 6; }
/* drv.c: the driver */
#include <stdio.h>
int scale_up(int v);
int main(void) { printf("%d\n", scale_up(7)); return 0; }$ gcc -c scale.c && ar rcs libscale.a scale.o
$ gcc -c drv.c
$ gcc -lscale drv.o -L. -o d1
$ gcc drv.o -L. -lscale -o d2
$ ./d2drv.o:drv.c:(.text+0x13): undefined reference to `scale_up'
collect2.exe: error: ld returned 1 exit status
42הפלט נאסף ב-MinGW ב-Windows, ובשורת השגיאה הוסרה הקידומת עם הנתיב של ld.exe; ב-Linux ההודעה נראית מעט אחרת והסדר זהה. הפקודה השלישית נכשלה והרביעית הצליחה, ולכן ./d2 מדפיס 42, כלומר 7 * 6.
ה-Linker סורק את הפריטים בשורת הפקודה לפי הסדר שבו נכתבו, מהראשון לאחרון, ולוקח מארכיון .a רק חברים שמגדירים שם שחסר לו בדיוק באותו רגע. ב-d1 הארכיון מגיע ראשון, כשעדיין לא חסר שום דבר, ולכן לא נלקח ממנו כלום; אחר כך drv.o מבקש את scale_up והארכיון כבר מאחור. ב-d2 האובייקט בא קודם, השם חסר, והארכיון שאחריו מספק אותו.
- איך
-lnameמחפש: ה-Linker בונה מהשם אתlibnameומנסה להתאים לו קובץ.soאו.a, קודם בתיקיות שנקבעו ב--Lואחר כך בתיקיות ברירת המחדל של המערכת. אם נמצאו שני סוגים, הוא בוחר.so, אלא אם ביקשתם-static; אם נמצא רק.a, הוא משתמש בו. כל-Lנבדק עבור כל ה--lשבפקודה, גם אלה שנכתבו לפניו. - ספרייה סטטית (
.a): ארכיון של קבצי אובייקט שנבנה בעזרתar. לקובץ ההרצה מועתקים רק החברים שהתוכנית זקוקה להם, ואין צורך ב--fPIC, שנדרש רק לספרייה משותפת. - ספרייה משותפת (
.so; ב-Windows.dll): אינה מועתקת לקובץ ההרצה, אלא נטענת בכל הרצה על ידי ה-dynamic linker. מכאן שאפשר להחליף אותה בגרסה חדשה בלי לקשר מחדש את התוכנית, שכמה תהליכים חולקים עותק אחד שלה בזיכרון, ושקובץ ההרצה קטן. הכליlddמציג ממה קובץ הרצה תלוי. -Wl: הכתיבgcc -Wl,optionמעביר אתoptionל-Linker כמות שהוא.
בניקוי קטעים מתים כדאי להבחין בין הדגלים לפי מה שכל אחד משנה, ולא לפי השם שלהם:
| דגל | השלב | השפעה על הקבצים |
|---|---|---|
-ffunction-sections, -fdata-sections | קומפילציה | התנהגות התוכנית לא משתנה. רק מבנה קובץ האובייקט משתנה: הקוד והנתונים מחולקים ליחידות קטנות שה-Linker יכול להתייחס אליהן בנפרד. |
-Wl,--gc-sections | קישור | קובץ ההרצה קטן יותר: יחידות שאף קוד לא מפנה אליהן נשארות בחוץ. זה הדגל היחיד בטבלה שמסיר קוד ונתונים. |
--print-gc-sections (עם -Wl, לפניו) | קישור | קובץ ההרצה אינו מושפע. בפלט של הקישור מתווספת רשימה, וההשלכה עצמה נובעת מדגל אחר. |
--sort-section=name (עם -Wl, לפניו) | קישור | משנה רק את הסדר שבו הקטעים מסודרים בקובץ שנוצר, ולא את התוכן שלהם. |
--strip-all (עם -Wl, לפניו) | קישור | קובץ ההרצה מאבד את טבלת הסמלים ואת מידע הדיבוג ונעשה קטן יותר; הקוד והנתונים נשארים. |
טעויות נפוצות
- בפקודה
gcc -lcalc use_lib.o -L.הבעיה היא שה--L.בא אחרי ה--l.-Lחל על כל הפקודה בלי קשר למקומו. הבעיה היא ש--lcalcבא לפניuse_lib.o. - אפשר להריץ קובץ
.oישירות. קובץ אובייקט אינו מקושר: חסרות לו כתובות סופיות והפניות חיצוניות לא נפתרו. undefined referenceהיא שגיאת הידור. היא מדווחת בשלב הקישור, על ידי ה-Linker (ld), אחרי שכל קבצי המקור כבר התקמפלו.- ההצהרה
extern int x;יוצרת משתנה חדש. היא רק מצהירה שההגדרה נמצאת במקום אחר ואינה מקצה זיכרון. - שני קבצים עם
static int seqמתנגשים בקישור.staticברמת הקובץ מגביל את הנראות לקובץ הבודד, ולכן אין התנגשות. - הדגל
-ffunction-sectionsמוחק פונקציות שאינן בשימוש. הוא רק מפריד לקטעים נפרדים. המחיקה נעשית ב-Linker, עם--gc-sections.
בדקו את עצמכם
איזו אות יציג nm עבור int total;, עבור static int lives = 3; ועבור extern int other; שהקוד משתמש בו?
B עבור total (גלובלי בלי ערך, .bss), d עבור lives (מקומי לקובץ ומאותחל בערך שאינו אפס, .data), ו-U עבור other (מוגדר בקובץ אחר).
הפקודה gcc -lgeo main.o -L. -o app נכשלת ב-undefined reference לפונקציה שמוגדרת ב-libgeo.a. מה מתקנים?
מעבירים את -lgeo אחרי main.o: gcc main.o -L. -lgeo -o app. כך כשה-Linker מגיע לארכיון, השם כבר חסר לו והוא שולף את החבר המתאים.
Makefile: בנייה לפי תלויות וזמני שינוי
נניח ששיניתם שורה אחת ב-reader.c בפרויקט של עשרה קבצים. אין סיבה להדר את כולם מחדש, ו-make קיים בדיוק בשביל זה: הוא משווה זמני שינוי של קבצים ומריץ רק את מה שהתיישן.
קובץ ההוראות של make נקרא Makefile (גם makefile מתקבל), ולקובץ בשם אחר מפנים עם make -f name. הקובץ בנוי מכללים: כל כלל נפתח בשורה target: prerequisites, ומתחתיה הפקודות שבונות את היעד.
CC = gcc
CFLAGS = -Wall -g
OBJS = reader.o parser.o
tool: $(OBJS)
$(CC) -o $@ $^
reader.o: reader.c shared.h
$(CC) $(CFLAGS) -c $<
parser.o: parser.c shared.h
$(CC) $(CFLAGS) -c $<
.PHONY: clean
clean:
rm -f $(OBJS) tool| נושא | מה חשוב לדעת |
|---|---|
| מתי יעד נבנה מחדש | כשהקובץ חסר, או כשאחת התלויות נערכה מאוחר ממנו. make משווה זמני שינוי של הקבצים, ואינו קורא את התוכן שלהם. |
| משתנים אוטומטיים בפקודה | $@ הוא היעד שנבנה, $< התלות הראשונה בלבד, ו-$^ כל התלויות. |
make בלי שם יעד | פועל על היעד הראשון בקובץ. אם הוא כבר מעודכן, מודפס is up to date ושום פקודה לא רצה. |
.PHONY | מסמן יעד שהוא פעולה ולא קובץ, כמו clean. |
make -n ו-make -j N | הראשון מציג את הפקודות בלי להריץ אותן, והשני מריץ עד N מהן במקביל. |
| קובץ כותרת בתלויות | אם shared.h רשום בכלל של קובץ אובייקט, שינוי בו יגרום לבנייה מחדש של אותו אובייקט. |
| תחילת שורת פקודה | רק תו TAB תקף שם. רווחים במקומו גורמים לשגיאה missing separator. |
קריאות מערכת (System call) מול פונקציות ספרייה
שאלה שחוזרת במבחנים היא אם פונקציה כלשהי נכנסת לליבה. כדי לענות צריך להבדיל בין קריאת מערכת (system call), כניסה לליבה (kernel) כדי לבקש שירות שתוכנית רגילה לא יכולה לבצע בעצמה, לבין פונקציית ספרייה, שהיא קוד רגיל שלפעמים מבצע קריאת מערכת בדרך.
הליבה נותנת שירות בארבעה תחומים עיקריים. רשת, וגם קבצים והתקנים (open, read, write, close); יצירה וסיום של תהליכים (fork, execve, wait, exit); ובקשת זיכרון נוסף (brk, mmap).
במעבר כזה המעבד עובר ממצב משתמש למצב ליבה ובסוף חוזר, וזה עולה הרבה יותר מקריאה רגילה לפונקציה. ב-Linux על x86-64 מכינים את הקלט לפני הכניסה: מספר שמזהה את השירות ב-RAX, והארגומנטים ב-RDI, RSI, RDX, R10, R8, R9. ההוראה syscall מעבירה את השליטה לליבה, והיא שונה מ-call הרגילה; אחרי החזרה הקוראת בודקת את RAX: זה הערך המוחזר, ומספר בטווח שבין -4095 ל--1 אומר שהקריאה נכשלה.
| הפונקציה | נכנסת לליבה? | הסבר |
|---|---|---|
write | כן, בכל קריאה | עטיפה דקה (thin wrapper) של libc. היא מקבלת מספר קובץ, כתובת ואורך, מציבה אותם יחד עם המספר 1 ב-RDI, RSI, RDX ו-RAX, וקוראת מיד לליבה. אין לה מאגר, ולכן הנתונים יוצאים באותה קריאה. |
read | כן, בכל קריאה | עטיפה דקה לקריאת המערכת המתאימה. |
printf | רק לפעמים | אוגרת טקסט במאגר בזיכרון המשתמש וקוראת ל-write כשצריך, למשל בירידת שורה במסוף. |
malloc | רק לפעמים | מבקשת מהליבה אזורים גדולים (brk או mmap) ומחלקת אותם בעצמה. |
strlen | אף פעם | רצה כולה במצב משתמש. |
system("cmd") | בעקיפין | אינה קריאת מערכת בפני עצמה אלא בנויה מעל כמה כאלה. היא יוצרת תהליך בן (fork או clone) שמחליף את עצמו ב-/bin/sh -c cmd בעזרת execve, וממתינה לו עם wait. |
כדי לראות אילו קריאות מערכת תוכנית מבצעת בפועל, מריצים אותה תחת strace.
תרחיש 33: write ישירה מול printf עם מאגר
#include <stdio.h>
#include <unistd.h>
int main(void) {
write(1, "direct\n", 7);
printf("buffered\n");
return 0;
}direct
bufferedהריצה מדפיסה שורה direct ואחריה שורה buffered, גם כשהפלט מופנה לקובץ. printf אינה כותבת מיד: היא מניחה את הטקסט במאגר פנימי של התהליך, והמאגר מתרוקן ל-write מאוחר יותר, בירידת שורה במסוף או כשהתוכנית מסתיימת בצורה תקינה. ה-write שבשורה הראשונה לא מחכה לשום מאגר, ולכן שבעת הבתים שלה, אל קובץ מספר 1 (הפלט הסטנדרטי), מגיעים ראשונים.
טעויות נפוצות
writeאוגרת תווים במאגר כמוprintf.writeפונה לליבה ישירות ואינה מבצעת אגירה (buffering) במרחב המשתמש.printfו-mallocהן קריאות מערכת. הן פונקציות ספרייה במצב משתמש שלפעמים פונות לקריאות מערכת מאחורי הקלעים.- לפונקציה
system()יש מספר קריאת מערכת משלה. היא פונקציית ספרייה שמפעילה shell בתהליך בן, באמצעות קריאות מערכת אחרות. - קריאת מערכת עולה כמו קריאה רגילה לפונקציה. היא כרוכה במעבר למצב ליבה ובחזרה, ולכן יקרה יותר.
בדקו את עצמכם
האם malloc(16) מבצעת בהכרח קריאת מערכת, ומה לגבי write(1, "x", 1)?
malloc לא בהכרח: היא מחלקת בלוקים מאזור שכבר קיבלה, ופונה ל-brk או ל-mmap רק כשצריך עוד. write כן, בכל קריאה.
סיכום
סיימתם לעבור על כל אבני הבניין של שאלות קריאת הקוד בשפת C. כדי לפתור שאלות כאלה בביטחון, עובדים בשיטה קבועה: מזהים מאקרו ופקודות עיבוד מקדים, בודקים את הטיפוסים והגדלים המדויקים, ומריצים טבלת מעקב צעד אחר צעד עד ה-printf האחרון.
- עיבוד מקדים ו-
inline:#include,#ifndefומאקרו עובדים על טקסט לפני הקומפילציה (שימו לב לסוגריים, להערכה כפולה ול-#/##), בעודinlineהיא פונקציה אמיתית עם בדיקת טיפוסים והערכת ארגומנט יחידה. - טיפוסים, ייצוג זיכרון ובקרת זרימה:
charחתום וגלישות, הבדל ביןsizeofל-strlenבמחרוזות, אריתמטיקתlongו-unsigned, קבועיenum, העתקה רדודה מול עמוקה ב-structעם ריפוד, בתים משותפים ו-Little Endian ב-union, קדימות^מול==, נפילתswitchוגבולותatoi. - פונקציות, מחסנית וערימה: תחביר מצביעים לפונקציות וטבלאות ניתוב, מוסכמות קריאה (
cdecl,stdcall,fastcall,x86-64), מסגרות LIFO ברקורסיה מולstaticוגלובלי, וניהול תקין שלmalloc,calloc,reallocו-freeללא דליפות או התנהגות לא מוגדרת. - שרשרת הבנייה וליבה: ארבעת שלבי
gcc(-E,-S,-cוקישור), קריאת טבלת הסמלים ב-nm, פתרוןundefined referenceו-multiple definition, סדר ספריות משמאל לימין, כלליMakefileוהבחנה ביןsystem callישיר לפונקציית ספרייה.
הטבלה הבאה מרכזת את כל 21 הנושאים שנבדקים במבחני קריאת קוד ב-C ואת הכלל המכריע בכל אחד מהם:
| מושג | הכלל שקובע את התוצאה |
|---|---|
Preprocessor | פועל על טקסט גולמי לפני ההידור, מלמעלה למטה; gcc -E מדפיס את הפלט שלו |
Macro | החלפת טקסט ישירה: קדימות לפי התוצאה המורחבת, ארגומנט מוחלף ומחושב בכל מופע; # הופך למחרוזת בלי הרחבה, ## מצמיד טוקנים |
#ifndef | שומר שורות רק כשהמאקרו לא הוגדר; include guard מגן בתוך קובץ מקור יחיד |
inline | המלצה למהדר בלבד; הארגומנט מחושב פעם אחת ומומר לטיפוס הפרמטר; התוצאה זהה לפונקציה רגילה |
^ (XOR) | ביט 1 כשהביטים שונים; x ^ x == 0; קדימות == גבוהה משל ^ |
enum | מתחיל ב-0 כברירת מחדל; כל קבוע ללא ערך ממשיך ב-+1 מהקודם; גודל ב-gcc הוא 4 בתים |
struct | השמה והעברה מעתיקות את כל השדות בערך (במצביע מועתקת רק הכתובת); הגודל כולל ריפוד (padding) |
union | כל השדות חולקים את אותם בתים; הגודל הוא השדה הגדול ביותר מעוגל ליישור; ב-x86 הסדר הוא Little Endian |
long | רוחבו 8 בתים ב-x86-64 תחת לינוקס, לעומת 4 בתים ב-Windows; ביטוי אריתמטי מחושב לפי טיפוס האופרנדים שלו |
char | תופס בית אחד, חתום כברירת מחדל ב-gcc x86-64; תו ליטרלי 'A' הוא int; sizeof מול strlen במחרוזות |
atoi | מדלג על רווחים, קורא סימן וספרות עד התו הלא-ספרתי הראשון; מחזיר 0 כשאין ספרות, בלי עיגול ובלי הקסדצימלי |
switch | קפיצה לתווית המתאימה והמשך ביצוע (fall-through) עד break; default רץ רק כשאין התאמה, בכל מיקום |
int (*f)(int, int) | מצביע לפונקציה, 8 בתים; f(a, b) ו-(*f)(a, b) הן אותה קריאה |
__cdecl / __fastcall | תוספי מהדר ל-32 סיביות בלבד: ב-cdecl הארגומנטים במחסנית והקוראת מסלקת אותם; ב-fastcall השניים הראשונים ב-ECX וב-EDX והנקראת מסלקת |
System call | כניסה לליבה דרך syscall; write היא עטיפה דקה, בעוד printf ו-system() הן פונקציות ספרייה |
Stack | לכל קריאה מסגרת נפרדת עם עותקים משלה, בסדר LIFO; משתנה static אינו יושב במחסנית |
Heap | הבלוק חי עד free, בלי קשר לפונקציה שהקצתה אותו; דליפת זיכרון אינה משנה את הפלט |
malloc | לא מאותחל, ואילו calloc מאפסת; realloc שומרת את התוכן ומחזירה כתובת חדשה; free(NULL) בטוחה |
Makefile | יעד נבנה מחדש כשתלות עודכנה אחריו, לפי זמן שינוי; כל שורת פקודה מתחילה ב-TAB |
Linker | undefined reference ו-multiple definition הן שגיאות קישור; static פרטי לקובץ; ספרייה באה אחרי האובייקטים שמשתמשים בה |
Object file | תוצר של gcc -c, לא ניתן להרצה; ב-nm: T, D, B, R, U, ואות קטנה לסמל מקומי |
לפני שמסמנים תשובה בשאלת מבחן, עוברים על הרשימה הזו. היא מסודרת לפי מה שרואים בקוד:
| אם בקוד יש... | עשו כך |
|---|---|
| קריאה רקורסיבית | רשמו מדרגות. מה שכתוב אחרי הקריאה העצמית מתבצע בעלייה, בסדר הפוך. |
קריאה מבלוק של malloc או ממשתנה מקומי לפני שנכתב אליהם, free של כתובת שלא הוקצתה, או שינוי של מחרוזת ליטרלית | זו התנהגות לא מוגדרת, ואין תוצאה שאפשר לחזות. זיכרון של calloc ומשתנים גלובליים או static מאופסים, וקריאה מהם מוגדרת. |
struct שהועתק וכולל מצביע | העותק והמקור חולקים את אותו בלוק, כי הועתקה רק הכתובת. |
sizeof | קבעו קודם מה הארגומנט: מערך (כל הבתים), מצביע (8), struct (כולל ריפוד) או union (השדה הגדול, מעוגל ליישור). |
ערך גדול שנכנס ל-char או לטיפוס unsigned | העבירו את הערך לתחום של הטיפוס: שארית בחלוקה ב-256 עבור char ו-unsigned char, ובכלל ב-2 בחזקת מספר הביטים. |
^ ו-== באותו ביטוי | ההשוואה קודמת ל-XOR, אלא אם יש סוגריים. |
| מאקרו | כתבו את הטקסט המוחלף כמות שהוא, עם הסוגריים שבגוף ההגדרה בלבד. |
switch | מצאו את התווית המתאימה והתקדמו שורה אחר שורה עד break. |
| שאלה על כמה קבצים | הפרידו בין שגיאת הידור, שנוצרת בתוך קובץ אחד, לבין שגיאת קישור, שנוצרת בין קבצים. |
| תשובה שנראית טבעית מדי | חשדו בה: סכום גדלי השדות כגודל struct, או 9 עבור מאקרו כפל בלי סוגריים, הן בדרך כלל המלכודת. |
בדקו את עצמכם
מה יהיה הפלט של קטע הקוד הבא בהידור עם gcc בסביבת לינוקס x86-64: #define TRIPLE(x) x + x + x ו-enum { A = 1, B, C = B * 4 }; וב-main: char ch = 122 + C; printf("%d %d\n", TRIPLE(C) * 2, ch);?
32 -126. B הוא 2 ולכן C = 8. ההרחבה של TRIPLE(C) * 2 היא 8 + 8 + 8 * 2 = 32. החישוב 122 + 8 = 130 גולש ב-char חתום אל 130 - 256 = -126.