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

שפת 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.

טיפוסגודל בבתיםדגשים חשובים
char1מוגדר בתקן כבית אחד בדיוק; ב-gcc על x86-64 הוא חתום (-128 עד 127)
short2שלם קצר עם סימן כברירת מחדל
int, unsigned int, float4גם enum ב-gcc תופס 4 בתים, וכך גם ליטרל תו כמו 'A'
long, long long, double8ב-Windows של 64 ביט long הוא 4 בתים בלבד, ולכן שאלות על long מציינות מערכת
כל סוגי המצביעים8זהה עבור int *, מצביע לפונקציה, או char * שמצביע למחרוזת של אלף תווים

שני כללי המצביעים נראים בקוד קצר אחד:

C
#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 7
  • v[2] ו-*(v + 2) נותנים את אותו איבר: ההזזה נמדדת באיברים ולא בבתים, ו-p[i] הוא כתיב מקוצר ל-*(p + i).
  • wipe קיבלה כתובת ולא עותק, ולכן האיפוס שלה נראה גם ב-main.
חזרה לתוכן העניינים

טבלת משתנים: מעקב מלא

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

תרחיש 1: לולאה עם שני משתנים שמשתנים יחד
C
#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
שלבksum += a * ka--
אתחול-sum = 1a = 4
איטרציה 111 + 4 * 1 = 5a = 3
איטרציה 225 + 3 * 2 = 11a = 2
איטרציה 3311 + 2 * 3 = 17a = 1

ההפחתה של a בסוף כל סיבוב משפיעה כבר על הסיבוב הבא: בסיבוב השני מכפילים ב-3 ולא ב-4. מי שמחשב את כל הסיבובים עם a = 4 ומוסיף את 1 ההתחלתי מקבל 25 במקום 17.

תרחיש 2: מעקב משולב על מאקרו, switch, struct ו-XOR
C
#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 הופכות לטקסט הבא:

C
int p = b.count - 3 * 4;
int q = ((4 - 2) * (4 - 2) * (4 - 2));
ביטוימה קורה בפועלערך
batoi(" 14units") מדלג על הרווח וקורא 14 עד התו 'u'kind='M', count=14
pבלי סוגריים במאקרו PROD, הכפל קודם לחיסור: 14 - 122
qהסוגריים שומרים על החיסור לפני הכפל: 2 * 2 * 28
sscore(0) נכנס ל-case 0, גולש ל-case 1 ועוצר (9); score(5) מגיע ל-default (11)20
byte255 + 2 = 257; unsigned char נחתך מודולו 2561
b.count ^ 6XOR בינארי: 1110 ^ 0110 = 10008
sizeof(struct Box)char בהיסט 0, שלושה בתי padding ליישור, int בהיסט 48

כל אחד מהפריטים האלה (מאקרו, switch, atoi, char, XOR ו-padding) מקבל חלק משלו בהמשך הנושא, ולכן כאן מספיק לעקוב אחרי השורות בטבלה.

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

printf, חלוקת שלמים והמרות

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

מצייןטיפוס מצופה ופלטדוגמה קצרה
%dשלם עם סימן (int)printf("%d", -5) מדפיס -5
%uשלם ללא סימן (unsigned int)printf("%u", 12u) מדפיס 12
%ld, %lulong ו-unsigned longprintf("%lu", 4000000000UL)
%zusize_t (תוצאה של sizeof או strlen)printf("%zu", sizeof(int)) מדפיס 4
%x, %X, %02Xבסיס 16 באותיות קטנות או גדולות; 02 מרפד באפס לשתי ספרותprintf("%02X", 13) מדפיס 0D
%cתו לפי קוד ASCIIprintf("%c", 68) מדפיס D
%sרצף תווים מהכתובת ועד בית '\0' הראשוןprintf("%s", "ok") מדפיס ok
%.1fdouble עם ספרה אחת אחרי הנקודה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: מצייני פורמט, חלוקת שלמים וקיצוץ פרמטר
C
#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 לא מצליח לאחד קבצי objectundefined reference לפונקציה שהוצהרה ולא מומשה, או multiple definition של משתנה שהוגדר בשני קבצי .c
התנהגות לא מוגדרת (UB)הקוד עובר קומפילציה, אך התקן מתיר כל תוצאהשינוי תו במחרוזת ליטרלית, free למצביע זבל, שימוש אחרי free, גלישת int עם סימן
דליפת זיכרוןבלוק ב-Heap שאבדה אליו הגישה ולא שוחררהתוכנית רצה ומדפיסה כרגיל; מערכת ההפעלה משיבה את הזיכרון עם סיום התהליך

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

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

ההבדל הקלאסי הוא בין שתי הצהרות שנראות כמעט זהות:

C
#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 עם הגדרה משורת הפקודה
C
/* calc.c */
#define RATE 5
#ifndef LIMIT
#define LIMIT 100
#endif
int total = RATE * 4; /* compute total */
int cap = LIMIT;
Bash
gcc -E -P calc.c
פלט
int total = 5 * 4;
int cap = 100;
Bash
gcc -E -P -DLIMIT=9 calc.c
פלט
int total = 5 * 4;
int cap = 9;
Bash
gcc -E -P -DLIMIT calc.c
פלט
int 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 NAMENAME מוגדר כמאקרושקול ל-#if defined(NAME)
#ifndef NAMENAME אינו מוגדר כמאקרושקול ל-#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
C
#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 50
  • WIDTH הוגדר כ-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: כותרת שנכללת פעמיים בלי הגנה
C
/* 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, תבנית שעוטפת את תוכן הכותרת:

C
/* 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
C
#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: ארבע קריאות מאקרו ללא סוגריים
C
#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 + 47
5 * ADD(2, 3)5 * 2 + 3כפל לפני חיבור: 10 + 313
SHL(1, 3) + 21 << 3 + 2חיבור לפני הזזה: 1 << 532
SHL(8 | 2, 1)8 | 2 << 1הזזה לפני |: 8 | 412

בקומפילציה עם -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++ ומונה
C
#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 שתופס רק את הפקודה הראשונה במאקרו
C
#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: הדבקת טוקנים, מחרוזות והרחבה דו-שלבית
C
#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:

C
#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: אותה פעולה בשתי צורות: ערך מוחלט והכפלה
C
#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.
בשפת C ליטרל כמו 'q' נראה כבית בודד אבל הוא ערך int, ולכן sizeof('q') הוא 4 (ב-C++ התשובה 1). ואילו "q" היא מערך של שני בתים: התו עצמו ובית הסיום '\0'.
תרחיש 13: חיתוך ערכים, קודי ASCII וגדלי ליטרלים
C
#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 68
  • sc: החיבור 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
C
#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 \03
strcat(b.code, "-07")d e v - 0 7 \06
b.code[3] = '_'d e v _ 0 7 \06
b.code[4] = '\0'd e v _ \0 7 \04
טעויות נפוצות
  • 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 סיביות)
C
#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
C
#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
WRITEREAD + 15
EXEC4 - 7-3
GUESTEXEC + 1 (לא 6)-2
DUPמפורש כשווה ל-NONE0
LASTDUP + 11
F3F2 + 1 כש-F2 = 1 << 2 = 45
טעויות נפוצות
  • מספור 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, | מסתפק באחת, ו-^ דורש בדיוק אחת:

Text
  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 ^ x0ערך מול עצמו מתאפס
x ^ 00x6aאפס הוא האיבר הנייטרלי
x ^ 0x35 ^ 0x350x6aאותו מפתח פעמיים מבטל את עצמו
x ^ (1u << 2)0x6eהופך רק את סיבית 2 (כיבוי הופך לדלוק ולהפך)
x ^ 0xFF0x95הופך את כל שמונה הסיביות הנמוכות

בנוסף, הסדר בשרשרת של ^ אינו משנה את התוצאה, כי האופרטור חילופי וקיבוצי.

החלפה בלי משתנה זמני נעשית בשלוש שורות ^= (כמו ב-xor_swap שלמטה), ועובדת רק כשהמצביעים מפנים לשני משתנים שונים. כשמעבירים לה את אותה כתובת פעמיים, השורה הראשונה היא p ^= p והמשתנה מתאפס ל-0. בנוסף ^ מוגדר רק על שלמים, ועל float, double או מצביע התוכנית לא תתקמפל.

תרחיש 17: קדימות השוואה, החלפת XOR ומתג סיביות
C
#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 0xd2
  • 13 ^ 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 מקונן
C
#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 ok
kקפיצה ראשוניתזרימת הביצועתוצאה
1case 1מוסיף 3, גולש ל-case 2, מוסיף 40, break43
2case 2מוסיף 40, break40
3defaultאין case 3: מוסיף 500, גולש ל-case 4, מוסיף 6000, break6500
4case 4מדלג על default, מוסיף 6000, break6000
5case 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...), ואינה מדווחת שגיאות.

  1. מדלגת על כל הרווחים שבתחילת המחרוזת.
  2. אם מופיע + או - אחד, זוכרת אותו כסימן.
  3. צוברת ספרות עשרוניות ברצף, עד התו הראשון שאינו ספרה, ואז עוצרת בלי הודעה.
  4. אם לא נקלטה אף ספרה, התוצאה 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
C
#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, נעצרת ב-x0
"+25m"קוראת +25, נעצרת ב-m25
"4 9"נעצרת ברווח שאחרי 44
"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} } לאיבר האמצעי יש lat 7 ו-lon 0.

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

תרחיש 20: מבנה לפי ערך, מצביע פנימי ומערך מבנים
C
#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 3
  • edit_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
C
#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 1
Text
src.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)100
b (double)818, הכפולה הקרובה של 8 (7 בתי ריפוד)
c (short)21616
סיום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: השוואת חמישה סידורי שדות והיסטים
C
#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
S1a: 0, b: 2, c: 4848
S2a: 0, b: 4, c: 89412
S3b: 0, a: 4, c: 5648
S4a: 0, d: 8, c: 1617824
S5d: 0, a: 8, c: 1011816

המבנים 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 ומערך גמיש

לעתים נדרשת שליטה ישירה על פריסת הזיכרון מעבר לכללי היישור הרגילים, ולכך משמשים שלושה כלים:

C
#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 4

Frame רגיל תופס 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), שהוא השדה האחרון בלי מספר בסוגריים. נקצה כותרת קצרה יחד עם הטקסט שאחריה בהקצאה אחת:

C
#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 alert

sizeof(struct Note) מודד רק את len (2 בתים), כי המערך הגמיש אינו נספר. מה שמאפשר לו להכיל טקסט הוא הבתים הנוספים שביקשנו ב-malloc.

תרחיש 23: אריזה ללא ריפוד, bit-fields ומערך גמיש
C
#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 t
  • WireHdr תופס 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 תווים באותו מקום, ולכתוב דרך חבר אחד ולקרוא דרך האחר:

C
#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.)

Text
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
C
#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: ארבע דרכים להפעיל את אותו מצביע
C
#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.
שדה ב-structstruct 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 ופונקציית עיבוד
C
#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
0plusplus(6, 2)8
1minusminus(8, 3)5
2timestimes(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: שלושה דפוסים של קריאות רקורסיביות
C
#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 3
Text
climb(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 = 18
  • climb מדפיסה רק אחרי שהקריאה הפנימית חזרה, ולכן הפלט 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 מול מונה מקומי רגיל
C
#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 והחזרת מבנה מהפונקציה
C
#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) ואינו עושה כלום.

C
#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 50

create_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: שמירת הבלוק הקודם לפני הקצאה חדשה
C
#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
C
#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הפונקציה מוגדרת בקובץ הזה, בקטע .textint run(void) { ... } (T) או static int helper(void) (t)
D / dמשתנה שהערך ההתחלתי שלו אינו אפס, בקטע .dataint mode = 4; (D) או static int seed = 7; (d)
B / bמשתנה בלי ערך התחלתי או עם אפס, בקטע .bssint flag; int count = 0; (B) או static int zero = 0; (b)
Rנתון לקריאה בלבד, בקטע .rodataconst 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 בקובץ שלישי
C
/* 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. הסיבה היא הסדר בשורת הפקודה.

C
/* 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; }
Text
$ 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
$ ./d2
פלט
drv.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, ומתחתיה הפקודות שבונות את היעד.

Text
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 עם מאגר
C
#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
Linkerundefined 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.

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