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

שפת C - קוד

C Language Essentials & Preprocessing

קטעי קוד ב-C שבהם קובעים מה יודפס: מאקרואים, #define, union, enum, switch וטיפוסים.

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

חומר לימוד

C Language Essentials & Preprocessing: מעקב ידני, המעבד המקדים ומאקרו

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

סביבת ההרצה בשאלות היא gcc על Linux בארכיטקטורת x86-64: char תופס בית אחד, short שני בתים, int ארבעה, ואילו long, double ומצביע תופסים שמונה בתים כל אחד (כלומר long ומצביע הם בני 64 ביט; ב-Windows, למשל, long הוא בן 4 בתים). ההנחה היא שאתם כבר מכירים משתנים, לולאות, פונקציות ומערכים בסיסיים.

החומר בנושא הזה מקיף ארבעה תחומים מרכזיים:

  • עיבוד מקדים ומאקרו: #define, #undef, התניה עם #if, #elif, #else, #ifdef ו-#ifndef, מאקרו עם פרמטרים, האופרטורים # ו-##, עטיפת do { } while (0), והשוואה מול typedef ומול inline (שמוזכרת כאן כחלופה הבטוחה למאקרו עם פרמטרים).
  • קבועים ומבנים מורכבים: enum כקבוע שלם, struct כולל העתקה ויישור בזיכרון, ו-union כולל Little Endian ו-tagged union.
  • טיפוסים והמרות: char וקודי ASCII, גלישה מטווח ערכים, long והגודל התלוי בפלטפורמה, והפונקציה atoi (גם דרך argc ו-argv).
  • זרימת ביצוע וביטים: switch כולל fall-through, מיקום default ושילוב בתוך לולאות, והאופרטור ^ (XOR) עם סדר הקדימות שלו.

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

איך עוקבים אחרי קוד C

שלושה שלבים: הרחבה, ביצוע, הדפסה

רוב הטעויות בשאלות מעקב קורות משתי סיבות: מדלגים ישר לחישוב בלי לפרוס קודם את ה-#define, או שמחשבים נכון את המספרים אבל מפספסים רווח, תו מפריד או \n בפלט הסופי.

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

  1. מעבר ראשון, התוצר הוא קוד מורחב: כותבים מחדש את התוכנית כפי שהמהדר יקבל אותה. כל ענף של #if, #ifdef או #ifndef שלא נבחר נעלם, וכל שם של מאקרו מוחלף בטקסט שהוא מייצג. עד שהכתיבה הזו מסתיימת לא מחשבים אף ערך.
  2. מעבר שני, התוצר הוא טבלת משתנים: עם הקוד המורחב ביד, מתקדמים פקודה אחר פקודה, ובכל פקודה רושמים בטבלה את הערך החדש של כל משתנה שהשתנה.
  3. מעבר שלישי, התוצר הוא מה שמופיע במסך: עוברים על מחרוזת הפורמט של printf משמאל לימין, משבצים בכל % את הערך הבא בתור, ומעתיקים בקפדנות כל רווח, סימן וירידת שורה שכתובים בה.
תרחיש 1: מעקב תלת-שלבי אחרי לולאה עם מאקרו
C
#include <stdio.h>
#define ROUNDS 3

int main(void) {
    int score = 10;
    for (int r = 0; r < ROUNDS; r++) {
        score = score * 2 - 1;
    }
    printf("score=%d rounds=%d\n", score, ROUNDS);
    return 0;
}
פלט
score=73 rounds=3

במעבר ההרחבה כל מופע של ROUNDS מוחלף ב-3, כך שתנאי הלולאה הוא r < 3 והארגומנט האחרון של printf הוא 3.

סיבובערך rחישוב score * 2 - 1score בסוף הסיבוב
1010 * 2 - 119
2119 * 2 - 137
3237 * 2 - 173
עצירה3-3 < 3 שקרי, יציאה מהלולאה

בהדפסה, מבין שני ה-%d הראשון מציג 73 והשני מציג 3, והמילים score= ו- rounds= עוברות לפלט בלי שינוי, כולל הרווח שלפני rounds.

טעויות נפוצות
  • הבנת הרעיון הכללי של הלולאה מספיקה כדי לבחור את התשובה הנכונה. המסיחים במבחן נבדלים לעתים קרובות רק בסדר הארגומנטים, ברווח חסר או בתוצאה של איטרציה אחת.
  • כשמגדירים #define TOTAL A + B, התוצאה של החיבור מחושבת פעם אחת כבר בשורת ההגדרה. ההגדרה שומרת טקסט ותו לא. כל הופעה של TOTAL בקוד תיפרש ל-A + B, והסכום נקבע מהטקסט המורחב לפי הקדימות שבמקום שבו המאקרו הופיע, ולא מראש.
חזרה לתוכן העניינים

מה printf מדפיס: מפרטי הפורמט

קחו את printf("%d km\n", 42). הארגומנט הראשון, מחרוזת הפורמט, מכתיב את הפלט: %d הוא מפרט שמציג את 42 כמספר עשרוני, ואילו km והתו \n (ירידת שורה) מגיעים למסך בלי שינוי. כשיש כמה מפרטים, כל אחד נוטל ארגומנט אחד בלבד, משמאל לימין, לפי הסדר שבו נכתבו.

בתרחיש שלמטה אותו משתנה tag מודפס פעם כתו ופעם כמספר. זה אפשרי כי char מקודם ל-int (integer promotion) עוד לפני שהוא מגיע ל-printf, והמפרט הוא שקובע איך להציג את הערך. לגבי מחרוזות, המרכאות בקוד רק מסמנות איפה הטקסט מתחיל ונגמר, ולכן %s מדפיס את התווים שביניהן ולא אותן.

מפרטהטיפוס הנקראאופן התצוגהדוגמת פלט
%dint (או char שקודם ל-int)עשרוני עם סימןprintf("%d", 'G') מדפיס 71
%uunsigned intעשרוני ללא סימן19
%ldlongעשרוני עם סימן7000000000 (ב-Linux x86-64, שבו long הוא 8 בתים)
%luunsigned longעשרוני ללא סימןprintf("%lu", (unsigned long)sizeof(double)) מדפיס 8
%zusize_t (תוצאת sizeof)עשרוני ללא סימן4
%x, %Xשלםבסיס 16 באותיות קטנות או גדולות, בלי 0xfe או FE
%02X, %04Xשלםבסיס 16 ברוחב קבוע, עם אפסים משמאל09 או 0009
%03d, %05dintעשרוני ברוחב קבוע עם אפסים משמאל, כמו בבסיס 16printf("%03d", 7) מדפיס 007
%cשלםהתו בטבלת ASCII שקודו הוא המספרprintf("%c", 72) מדפיס H
%sמצביע לתו ראשון במחרוזתכל התווים עד '\0' ללא מרכאותpass
%.1f, %.2fdoubleנקודה צפה עם ספרה אחת או שתיים אחרי הנקודה4.2 או 2.75
תרחיש 2: הצגת ערכים במפרטים שונים בשורת פלט אחת
C
#include <stdio.h>

int main(void) {
    int code = 171;
    char tag = 'M';
    printf("%d|%c|%x|%X|%04X\n", code, tag, code, code, 11);
    printf("%d|%c\n", tag, 78);
    printf("%.2f|%zu|%s\n", 7.0 / 4, sizeof(double), "done");
    return 0;
}
פלט
171|M|ab|AB|000B
77|N
1.75|8|done

הערך 171 הוא 10 * 16 + 11, ולכן בבסיס 16 הוא ab (או AB ב-%X). המספר 11 הוא B, ועם %04X נוספים שלושה אפסים משמאל לקבלת 000B.

התו 'M' יושב בקוד ASCII 77, והקוד 78 שייך לתו 'N'. החילוק 7.0 / 4 מתבצע ב-double ומחזיר 1.75, וגודל double הוא 8 בתים.

טעויות נפוצות
  • הקריאה printf("%c", 72) מדפיסה את המספר 72. המפרט %c ממיר את המספר לתו ה-ASCII המתאים לו, ולכן יודפס H.
  • המפרט %x מדפיס אוטומטית 0x לפני הספרות ההקסדצימליות. %x ו-%X מציגים ספרות בלבד; קידומת 0x תופיע רק אם נכתבה במפורש במחרוזת הפורמט.
  • המפרט %s כולל בפלט גם את המרכאות שסביב המחרוזת. המרכאות קיימות רק בקוד המקור לסימון גבולות הליטרל ואינן נשמרות בזיכרון.
בדקו את עצמכם
מה תדפיס השורה printf("[%c|%d|%x]\n", 'k', 'k', 'k');?

[k|107|6b], כי קוד ה-ASCII של 'k' הוא 107, ובבסיס 16 הערך הוא 6 * 16 + 11 = 6b.

מה תדפיס השורה printf("%04d|%x\n", 12, 202);?

0012|ca, כי %04d מרפד לארבע ספרות, ו-202 = 12 * 16 + 10 = ca באותיות קטנות.

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

אופרטורים שחוזרים במעקב

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

רמהאופרטורים (מהגבוהה לנמוכה)דגש למעקב
1() [] . -> x++ x--סוגריים, גישה למערך/מבנה, ו-x++ / x-- שמשנים רק אחרי שהערך נלקח
2++x --x -x ! ~ (type) sizeofאופרטורים אונאריים
3* / %כפל, חילוק שלמים ושארית
4+ -חיבור וחיסור
5<< >>הזזת ביטים
6< <= > >=השוואות סדר
7== !=שוויון ואי-שוויון (גבוה מביטים!)
8&AND על ביטים
9^XOR על ביטים
10|OR על ביטים
11&&AND לוגי
12||OR לוגי
13?:אופרטור משולש (כולל נקודת רצף אחרי התנאי)
14= += -= *= /= |= &= ^=השמות (כל אגף ימין מחושב תחילה)
  • קיצוץ מ-double ל-int: השמה למשתנה int או העברה לפרמטר int חותכות את השבר בלי עיגול (8.95 הופך ל-8).
  • חילוק ושארית של שלמים: חילוק בין שני int זורק את השארית (19 / 4 הוא 4), והאופרטור % מחזיר אותה (19 % 4 הוא 3).
  • הגדלה לפני נטילת הערך מול אחריה: ++z מעלה את z לפני שהערך נלקח לביטוי, בעוד z++ מוסר את הערך הישן ומגדיל רק לאחר מכן.
  • השמה עם פעולה: ב-t -= d + 3 נחשב קודם כל האגף הימני כגוש אחד, ולכן המשמעות היא t = t - (d + 3) ולא t = t - d + 3. עם t = 20 ו-d = 4 מתקבל 13.
  • האופרטור c ? a : b: מחושב התנאי, ואז ענף אחד בלבד. הענף השני נשאר כלא היה, ולכן ++ שכתוב בו לא מתבצע. בין סוף חישוב התנאי (כולל תופעות הלוואי שלו) לתחילת הענף חוצה קו שנקרא נקודת רצף (sequence point), ובזכותו מאקרו מקסימום שקיבל i++ בתנאי עדיין נותן תוצאה מוגדרת; זה יידון בחלק על ארגומנט שמחושב פעמיים.
  • ביטים והזזות: מדליקים ביט בעזרת | ומסכה, ומכבים אותו בעזרת & והיפוך המסכה. אם flags הוא 1011 0110 (0xB6), הפקודה flags &= ~0x10 מאפסת רק את הביט שמשקלו 16 ומותירה 1010 0110 (0xA6). הזזה שמאלה בביט אחד כופלת מספר חיובי ב-2, והזזה ימינה בביט אחד מחלקת אותו ב-2 ומאבדת את הביט הנמוך.
תרחיש 3: תרגול משולב של קדימות, הגדלה וביטים
C
#include <stdio.h>

int main(void) {
    int x = 19, y = 4;
    printf("%d %d %d %d\n", x + y * 2, (x + y) * 2, x / y, x % y);

    int z = 10;
    int a = ++z;     /* z becomes 11 first, a gets 11 */
    int b = z++;     /* b gets 11, then z becomes 12   */
    printf("%d %d %d\n", a, b, z);

    unsigned char reg = 0x15;   /* 0001 0101 */
    reg |= 0x02;                /* 0001 0111 = 0x17 */
    reg &= ~0x04;               /* 0001 0011 = 0x13 */
    printf("%02X %d %d\n", reg, 6 << 2, 64 >> 3);

    printf("%d\n", x < y ? x : y);

    double avg = 8.95;
    int whole = avg;            /* assigning a double to an int truncates */
    printf("%d\n", whole);
    return 0;
}
פלט
27 46 4 3
11 11 12
13 24 8
4
8

בשורה הראשונה y * 2 מחושב לפני החיבור (19 + 8 = 27), ואילו הסוגריים ב-(x + y) * 2 הופכים את הסדר ל-23 * 2 = 46. בהמשך, ++z מעלה ל-11 ומוסר 11 ל-a, ואז z++ מוסר 11 ל-b ומעלה את z ל-12.

האוגר reg עובר מ-0001 0101 (0x15) ל-0001 0111 (0x17) ואז ל-0001 0011 (0x13), 6 << 2 הוא 6 * 4 = 24, ו-64 >> 3 הוא 64 / 8 = 8.

טעויות נפוצות
  • הביטוי 19 / 4 ב-C מחזיר 4.75 או מתעגל ל-5. כאשר שני האופרנדים הם שלמים, החילוק קוצץ את השארית ומחזיר 4.
  • בביטוי c ? a : b מחושבים תחילה גם a וגם b, ואז נבחר אחד מהם. התוכנית מעריכה רק את הענף שנבחר לפי התנאי; הענף האחר אינו רץ כלל.
  • ביטוי כמו x + y * 2 מחושב משמאל לימין: קודם x + y ואז כפול 2. לכפל קדימות גבוהה יותר מחיבור בלי קשר לסדר הכתיבה.
בדקו את עצמכם
עבור int m = 23, n = 5;, מה ידפיס printf("%d %d %d", m / n, m % n, m - n * 3);?

4 3 8, כי 23 / 5 = 4, השארית היא 3, ובביטוי השלישי n * 3 מחושב קודם: 23 - 15 = 8.

עבור int k = 4;, מהם הערכים של res ו-k אחרי int res = k++ + 9;?

res שווה 13 ו-k שווה 5, כי k++ תורם את הערך הישן 4 ורק אחר כך גדל.

עבור unsigned char f = 0x09;, מה יודפס ב-%02X אחרי f |= 0x04; f &= ~0x01;?

0C, כי 1001 | 0100 נותן 1101 (0x0D), וכיבוי ביט 0 משאיר 1100 (0x0C).

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

המעבד המקדים (Preprocessor)

מה המעבד המקדים עושה ומתי

הפקודה gcc -E file.c עוצרת את הקומפילציה מיד אחרי העיבוד המקדים ומדפיסה את התוצאה, כלומר את הקוד שהמהדר באמת יקבל. בקוד הזה המאקרו כבר הוחלפו, ענפי הידור מותנה שלא נבחרו נעלמו וכל הערה הפכה לרווח בודד.

שימו לב שבפלט של gcc -E עדיין מופיעות שורות שמתחילות ב-#, למשל # 1 "file.c". אלה סימוני מקום (line markers) שבעזרתם המהדר מציין בהודעות השגיאה את שם הקובץ ואת מספר השורה; הדגל -P מסיר אותם.

נתחיל בניסוי: שתי פונקציות, והמאקרו מוגדר בתוך הראשונה בלבד. הפלט שלמטה הוא התוצאה של gcc -E -P על הקובץ.

C
void alpha(void) {
    #define LIMIT 7
    int a = LIMIT;
}

void beta(void) {
    int b = LIMIT;
}
פלט
void alpha(void) {
    int a = 7;
}
void beta(void) {
    int b = 7;
}

LIMIT הוחלף גם ב-beta, כי המעבד המקדים אינו מזהה סוגריים מסולסלים ואין לו מושג של גוף פונקציה. הוא קורא שורות מלמעלה למטה, ומאקרו חי מהשורה שהגדירה אותו ועד #undef עם אותו שם, ואם אין כזה, עד סוף הקובץ.

מאותה סיבה הוא גם אינו מכיר טיפוסים, משתנים, תחביר או תחומי הכרה (scope): הוא עובד על טקסט בלבד, לפני שהמהדר התחיל, ותפקידיו שניים: האחד, ביצוע הנחיות, כלומר שורות שהתו הראשון בהן שאינו רווח הוא # (#include, #define, #undef, #if, #ifdef, #ifndef, #elif, #else, #endif, #error ו-#pragma), ולכן גם #define מוזח בתוך פונקציה נשאר הנחיה תקפה; השני, החלפת שמות של מאקרו בשורות קוד רגילות.

  • אין כתובת ואין טיפוס: #define אינו יוצר משתנה או קבוע, אלא רשומה בטבלת כללי החלפה שקיימת רק עד סוף העיבוד המקדים.
  • #include אינו מביא קוד של פונקציות: הוא מדביק כטקסט, במקום השורה, את הקובץ שנקרא, ובו הצהרות כמו אלה של printf ו-atoi. את הקוד עצמו מצרף ה-linker, בשלב מאוחר יותר.
טעויות נפוצות
  • בכתיבת #define N 10; הערך של N הוא 10 והנקודה-פסיק היא סוף ההנחיה. הנקודה-פסיק נכללת בטקסט ההחלפה. בהצהרה כמו int arr[N]; מתקבל int arr[10;];, שנכשלת בקומפילציה.
  • השורה #include <stdio.h> מצרפת לתוכנית את הקוד של printf. היא מדביקה הצהרות כטקסט בלבד. את קוד הפונקציות מחבר ה-linker בשלב נפרד, אחרי הקומפילציה.
  • מאקרו שהוגדר בתוך main חי עד סוף main בלבד. המעבד המקדים אינו רואה סוגריים מסולסלים. ההגדרה חיה עד #undef או עד סוף הקובץ, גם בפונקציות שאחרי main.
  • המעבד המקדים יעצור על שגיאת תחביר או על חוסר התאמה בין טיפוסים. אין לו הבנה של שפת C מעבר להנחיות. הטקסט שהוא מוציא נבדק רק אחר כך אצל המהדר, ושם מתגלות השגיאות.
חזרה לתוכן העניינים

מאקרו פשוט: #define והחלפת טקסט

נניח ש-UNIT הוא 6 ו-STEP הוגדר כ-UNIT + 2. מי שמצפה ש-UNIT * STEP יהיה 48 יופתע, כי התוצאה היא 38. הסיבה: #define NAME text (מאקרו פשוט, object-like macro) שומר טקסט ולא ערך, ו-text מודבק מילה במילה בלי חישוב ובלי סוגריים.

  • אחרי ההדבקה הטקסט החדש נסרק שוב, ולכן מאקרו שהופיע בתוך הגוף (כמו UNIT בתוך STEP) מוחלף גם הוא.
  • סוגריים מופיעים בתוצאה רק אם נכתבו בהגדרה עצמה; המעבד לא מוסיף אותם.
  • מוחלף רק שם שלם: אותו שם בתוך מזהה ארוך יותר (כמו STEPS) או בתוך מחרוזת ("STEP") נשאר כפי שהוא.

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

תרחיש 4: מאקרו בתוך מאקרו: בלי סוגריים ועם סוגריים
C
#include <stdio.h>
#define UNIT 6
#define STEP UNIT + 2
#define SAFE_STEP (UNIT + 2)

int main(void) {
    int raw = UNIT * STEP;
    int safe = UNIT * SAFE_STEP;
    printf("%d %d\n", raw, safe);
    return 0;
}
פלט
38 48

אחרי הרחבת המאקרו (כפי שמראה gcc -E), שתי השורות ב-main נראות כך:

C
int raw = 6 * 6 + 2;
int safe = 6 * (6 + 2);

ב-raw הכפל קודם ולכן 6 * 6 + 2 נותן 38. ב-safe הסוגריים שבהגדרה נשמרו בהדבקה, ולכן מחושב 6 * 8 = 48.

טעויות נפוצות
  • המעבד המקדים עוטף אוטומטית כל החלפת #define בסוגריים. סוגריים מופיעים בהרחבה רק אם נכתבו במפורש בהגדרת המאקרו.
  • אם UNIT הוא 6 ו-STEP הוא UNIT + 2, אז ערכו של STEP הוא 8 ולכן UNIT * STEP הוא 48. STEP מייצג את הטקסט UNIT + 2 ולא תוצאה מספרית שמורה, ולכן הביטוי מתפרק ל-6 * 6 + 2.
בדקו את עצמכם
נתונים #define MIN_VAL 10 ו-#define TARGET MIN_VAL + 4. מה ערכו של TARGET * 2?

18, כי ההרחבה היא 10 + 4 * 2, והכפל קודם לחיבור.

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

#undef, הגדרה מחדש וסדר השורות

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

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

למה gcc מתלונן כשמגדירים את אותו שם פעם שנייה עם טקסט אחר? כי לכל שם מותרת הגדרה פעילה אחת בכל נקודה בקובץ, וסתירה היא הפרה של כללי השפה. כדי להחליף ערך כחוק, מוחקים קודם את הרשומה עם #undef NAME (מכאן והלאה השם אינו מאקרו), וכותבים אחריה #define NAME ... חדש.

C
#include <stdio.h>
#define TAX 5
#define TAX 12

int main(void) {
    printf("%d\n", TAX);
    return 0;
}
פלט
tax.c:3:9: warning: 'TAX' redefined
    3 | #define TAX 12
      |         ^~~
tax.c:2:9: note: this is the location of the previous definition
    2 | #define TAX 5
      |         ^~~

זו האזהרה ש-gcc מדפיס בקומפילציה של הקובץ tax.c. התוכנית עדיין רצה ומדפיסה 12, ואחרי הוספת #undef TAX לפני השורה השנייה האזהרה נעלמת.

תרחיש 5: שורת ההגדרה מול שורת השימוש
C
#include <stdio.h>
#define TAX 5
static int first_tax = TAX;
#define DOUBLE_TAX (TAX * 2)
#undef TAX
#define TAX 12

void init_cfg(void) {
#define HIDDEN 99
}

int main(void) {
    printf("%d %d %d\n", first_tax, DOUBLE_TAX, HIDDEN);
    return 0;
}
פלט
5 24 99

בשורת first_tax ההגדרה הפעילה היא TAX = 5, והשורה הופכת ל-static int first_tax = 5;. DOUBLE_TAX נרשם באותו רגע כטקסט (TAX * 2) בלבד, בלי חישוב.

ב-main הקריאה DOUBLE_TAX נפרסת ל-(TAX * 2), ובאותו רגע TAX הוא 12, ולכן התוצאה 24. HIDDEN הוגדר בגוף init_cfg, אבל גבולות פונקציה אינם קיימים בעיני המעבד המקדים, ולכן main רואה אותו.

טעויות נפוצות
  • DOUBLE_TAX קיבל את הערך 10 כבר בשורת ה-#define שלו. שורת #define אינה מחשבת ביטויים ואינה מרחיבה מאקרו פנימיים עד שורת השימוש.
  • אחרי #undef TAX הערך של TAX הופך ל-0. אחרי #undef השם כבר אינו מאקרו ופשוט נשאר כמות שהוא בטקסט. ההפיכה ל-0 קיימת רק בתוך תנאי של #if, ושם כל מזהה בלי הגדרה נספר כאפס.
  • ההגדרה האחרונה בקובץ משנה בדיעבד גם שימושים מוקדמים יותר. הרחבת הטקסט היא חד-כיוונית מלמעלה למטה לפי ההגדרה הפעילה בכל שורה.
  • הגדרה מחדש של מאקרו סוכמת את שני הערכים. בכל מקום בקובץ אפשר להסתמך על הגדרה אחת בלבד של השם. מי שרוצה ערך אחר מבטל קודם ואז מגדיר מחדש.
בדקו את עצמכם
בקובץ כתובים לפי הסדר: #define W 4, static int a = W;, #define HALF (W / 2), #undef W, #define W 14. מה ידפיס printf("%d %d", a, HALF) בתוך main?

4 7. המשתנה a הורחב כש-W היה 4, ואילו HALF הורחב ב-main כש-W כבר היה 14.

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

#if, #elif ו-#else

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

מה קורה כששני תנאים בשרשרת נכונים? רק הראשון משפיע: משרשרת #if / #elif / #else נשאר ענף אחד לכל היותר, וכל השאר נמחקים. #elif הוא "אחרת אם", #else נבחר רק כשאף תנאי קודם לא התקיים, וכל שרשרת נסגרת ב-#endif.

קחו את #if LEVEL > 2 || DEBUG_MODE כש-DEBUG_MODE אינו מוגדר בשום מקום: אין כאן שגיאה, והמזהה נספר כ-0. הערכת תנאי נעשית בשני שלבים, קודם החלפת כל המאקרו בערכיהם, ואחר כך איפוס של כל שם שנשאר בלי הגדרה. בתנאי מותרים מספרים, האופרטורים &&, ||, !, == ו->, והצורה defined(NAME) שמחזירה 1 כששם קיים כמאקרו ו-0 כשלא.

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

תרחיש 6: שרשרת תנאים ומזהה שאינו מאקרו
C
#include <stdio.h>
#define STAGE 4
#define DRY_RUN 0

int main(void) {
#if STAGE >= 4 && DRY_RUN
    printf("dry\n");
#elif STAGE >= 4 || UNSET_OPT
    printf("live\n");
#else
    printf("off\n");
#endif

#if UNSET_OPT == 0
    printf("unset is zero\n");
#endif
    return 0;
}
פלט
live
unset is zero

הבדיקה הראשונה היא 4 >= 4 && 0 (שקר), ולכן ענף dry נמחק. הבדיקה של #elif היא 4 >= 4 || 0 (כי UNSET_OPT אינו מאקרו ונחשב 0), והיא מתקיימת, כך שנבחר live וענף #else נזרק.

בבלוק השני UNSET_OPT מוערך שוב כ-0, ולכן 0 == 0 מתקיים ומדפיס unset is zero.

טעויות נפוצות
  • הנחיית #if יכולה לבדוק ערך של משתנה רגיל בזמן ריצה. התנאי מוכרע לפני הקומפילציה, ולכן המעבד המקדים רואה רק מאקרו וקבועים שלמים.
  • אם גם התנאי של #if וגם התנאי של #elif אמיתיים, שניהם מתבצעים. מכל שרשרת #if-#elif-#else נשאר רק הענף הראשון שמתקיים.
  • התנאי STAGE > 4 מתקיים כאשר STAGE מוגדר כ-4. 4 אינו גדול ממש מ-4; כדי לכלול שוויון יש לכתוב >=.
בדקו את עצמכם
נתון #define PRIORITY 2. איזה ענף יישאר בשרשרת #if PRIORITY > 2 (high), #elif PRIORITY (mid), #else (low)?

mid, כי 2 > 2 שקרי, ואילו PRIORITY לבדו הוא 2 (שונה מ-0) ולכן אמיתי.

ומה יישאר אם PRIORITY יוגדר כ-0?

low, כי גם 0 > 2 וגם 0 שקריים.

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

#ifdef, #ifndef וערכי ברירת מחדל

אפשר לטעות ולחשוב ש-#ifdef RETRIES נכשל כש-RETRIES מוגדר כ-0, אבל הוא מצליח. #ifdef NAME ו-#ifndef NAME (קיצורים ל-#if defined(NAME) ול-#if !defined(NAME)) שואלים רק אם השם קיים בטבלת המאקרו, ואינם קוראים את הערך שלו. לכן גם #define AUDIT בלי ערך נחשב מוגדר, בעוד משתנה C באותו שם אינו נחשב.

נניח שהכותרת twice.h מכילה גוף של פונקציה, ושקובץ main.c מכלל אותה פעמיים (למשל פעם ישירות ופעם דרך כותרת אחרת). בלי הגנה המהדר רואה את אותה פונקציה מוגדרת פעמיים, והקומפילציה נכשלת. הקובץ twice.h ואחריו main.c והפלט של gcc -c main.c:

C
int twice(int n) { return n * 2; }
C
#include "twice.h"
#include "twice.h"
פלט
In file included from main.c:2:
twice.h:1:5: error: redefinition of 'twice'
    1 | int twice(int n) { return n * 2; }
      |     ^~~~~
In file included from main.c:1:
twice.h:1:5: note: previous definition of 'twice' with type 'int(int)'
    1 | int twice(int n) { return n * 2; }
      |     ^~~~~

משמר הכללה (include guard) פותר את זה בבדיקה שכבר הכרתם: כל תוכן הכותרת עטוף ב-#ifndef TWICE_H, ושורת #define TWICE_H פותחת את הבלוק.

C
#ifndef TWICE_H
#define TWICE_H
int twice(int n) { return n * 2; }
#endif

ב-#include הראשון TWICE_H עדיין לא קיים, ולכן התוכן נכנס והשם נרשם. ב-#include השני הוא כבר קיים, ולכן הבלוק נמחק כולו. עם הכותרת המוגנת, gcc -E -P main.c על אותו main.c מוציא את הפונקציה פעם אחת בלבד, והקומפילציה מצליחה:

C
#include "twice.h"
#include "twice.h"
פלט
int twice(int n) { return n * 2; }

המשמר פועל רק בתוך קובץ .c אחד, כי כל קובץ .c מעובד בנפרד. קיימת גם חלופה קצרה: השורה #pragma once בראש הכותרת. היא אינה מוגדרת בתקן השפה, אבל gcc, clang ו-MSVC מקבלים אותה.

אותה בדיקה משמשת גם להגדרת ערך ברירת מחדל: #ifndef POOL_SZ, מתחתיה #define POOL_SZ 48, ובסוף #endif.

מצב לפני הבלוקמה קורה בבלוקהערך של POOL_SZ
השם לא הוגדרהתנאי מתקיים, והשורה #define נקראת48
השם כבר הוגדר (בקובץ אחר או משורת הפקודה)התנאי נכשל, והבלוק כולו נמחקהערך שהיה קיים

מי כותב את הערך הקיים משורת הפקודה? מי שמקמפל, עם -D: gcc -DPOOL_SZ=256 נותן 256, ו--DPOOL_SZ בלי ערך נותן 1. הבדיקה עצמה רק שואלת, והרישום נעשה בשורת ה-#define; ובהיעדר -D בשאלה, ההנחה היא שהמאקרו החיצוני פשוט אינו קיים.

תרחיש 7: מאקרו ריק, מאקרו עם ערך 0 וברירת מחדל
C
#include <stdio.h>
#define AUDIT
#define RETRIES 0

#ifndef POOL_SZ
#define POOL_SZ 48
#endif

int main(void) {
#ifdef AUDIT
    printf("audit on\n");
#endif
#ifdef RETRIES
    printf("retries=%d\n", RETRIES);
#endif
#ifndef AUDIT
    printf("disabled\n");
#else
    printf("else active\n");
#endif
    printf("%d\n", POOL_SZ);
    return 0;
}
פלט
audit on
retries=0
else active
48

למרות של-AUDIT אין ערך ול-RETRIES יש ערך 0, שניהם רשומים כמאקרו ולכן שני ה-#ifdef מתקיימים, ו-#ifndef AUDIT עובר אל ה-#else. כיוון ש-POOL_SZ לא הוגדר קודם, הוא מקבל 48.

אם מקמפלים את אותה תוכנית עם -DPOOL_SZ=256, ההדפסה האחרונה היא 256, ועם -DPOOL_SZ בלבד היא 1. בשני המקרים בלוק ה-#ifndef נמחק.

טעויות נפוצות
  • אם a.c ו-b.c מכללים את shape.h, המשמר שבתוכה מבטיח שההגדרה תופיע פעם אחת בכל התוכנית. המעבד המקדים מתחיל כל קובץ .c מחדש עם טבלת מאקרו ריקה, ולכן המשמר מגן רק על הכללה כפולה בתוך אותו קובץ.
  • #ifdef VERBOSE מתעלם מ-#define VERBOSE ריק ומ-#define VERBOSE 0, כי אין להם ערך ממשי. הבדיקה שואלת רק אם השם רשום בטבלה. ריק ו-0 רשומים שניהם, והבלוק נשאר.
  • כש-LIMIT כבר מוגדר כ-3 משורת הפקודה, הבלוק #ifndef LIMIT עם #define LIMIT 10 מחליף אותו ל-10. השם קיים, ולכן התנאי נכשל והבלוק נמחק יחד עם ה-#define שבו, והערך 3 נשאר.
  • השורה #ifndef NAME לבדה רושמת את NAME אם הוא חסר. אין בה שום כתיבה. הרישום מתבצע רק בשורת #define שבתוך הבלוק, וגם היא פועלת רק כשהבלוק נשאר.
בדקו את עצמכם
בקובץ מופיע #define FLAG 0, ואחריו #ifdef FLAG שמדפיס YES ו-#else שמדפיס NO. מה יודפס?

YES, כי FLAG מוגדר כמאקרו והערך 0 אינו מבטל זאת.

קובץ מכיל #ifndef DEPTH, #define DEPTH 12, #endif ומדפיס את DEPTH. מה יודפס עם gcc -DDEPTH=5 ומה בלי דגל?

עם הדגל יודפס 5 (כי DEPTH כבר מוגדר והבלוק נזרק), ובלי דגל יודפס 12.

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

מאקרו עם פרמטרים (Macro)

איך מאקרו עם פרמטרים מתרחב

נתחיל מקריאה שנראית תמימה: RECT_AREA(a + 2, 5) כשהמאקרו מוגדר כ-#define RECT_AREA(w, h) w * h. המעבד המקדים אינו מעביר ערכים: הוא מכניס את הטקסט a + 2 במקום w, ואת הטקסט 5 במקום h.

C
#include <stdio.h>
#define RECT_AREA(w, h) w * h

int main(void) {
    int a = 3;
    int r = RECT_AREA(a + 2, 5);
    printf("%d\n", r);
    return 0;
}
פלט
13

בפועל נוצרה השורה int r = a + 2 * 5;, ולכן 13 ולא 25. אין כאן מסגרת מחסנית, העתקת ערכים או ערך מוחזר, אלא רק טקסט שמחליף טקסט, כולל האופרטורים שבתוך הארגומנט.

בהגדרה הסוגר הפותח חייב לבוא מיד אחרי השם. אם מפרידים ביניהם ברווח, מתקבל מאקרו פשוט שהטקסט שלו מתחיל ב-(a, b), והקריאה משתבשת:

C
#define ADD(a, b) a + b
#define ADD2 (a, b) a + b
int z1 = ADD(1, 2);
int z2 = ADD2(1, 2);
פלט
int z1 = 1 + 2;
int z2 = (a, b) a + b(1, 2);

הפלט כאן הוא תוצאת gcc -E -P: ב-z2 נשאר הטקסט (1, 2) מיותם אחרי ההחלפה, והשורה אינה תקינה כקוד.

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

תרחיש 8: מאקרו מקונן מול פונקציה מקוננת
C
#include <stdio.h>
#define MUL5(x) x * 5
#define INC4(y) y + 4

static int mul5_fn(int x) { return x * 5; }
static int inc4_fn(int y) { return y + 4; }

int main(void) {
    int val = 2;
    int m_res = MUL5(INC4(val));
    int f_res = mul5_fn(inc4_fn(val));
    printf("%d %d %d\n", m_res, f_res, val);
    return 0;
}
פלט
22 30 2

ב-MUL5(INC4(val)) הארגומנט INC4(val) מורחב קודם ל-val + 4, ואז הוא מוצב בגוף של MUL5 כטקסט, בלי סוגריים: val + 4 * 5. הכפל קודם לחיבור, ולכן 4 * 5 = 20 ובסך הכול 2 + 20 = 22.

בפונקציות מחושבת קודם inc4_fn(2) שמחזירה 6, ורק אז mul5_fn(6) שמחזירה 30. המשתנה val נשאר 2 בשני המקרים כי אין בגופים ++ או השמה.

טעויות נפוצות
  • הביטוי y + 4 בגוף המאקרו מגדיל את המשתנה שהועבר אליו. חיבור רגיל אינו משנה משתנים; רק ++, -- או השמה משנים את ערך המשתנה.
  • המאקרו הפנימי INC4(val) הופך ל-6 לפני שהוא מוצב במאקרו החיצוני. ההרחבה של הארגומנט מייצרת את הטקסט val + 4 ולא את המספר 6. הערך נקבע רק אחרי שכל ההחלפות הסתיימו, מתוך הטקסט שהתקבל.
בדקו את עצמכם
נתונים #define SUB1(x) x - 1 ו-#define DBL(x) x * 2. מה הערך של DBL(SUB1(10))?

8, כי ההרחבה היא 10 - 1 * 2, והכפל קודם לחיסור (10 - 2).

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

סוגריים וקדימות אופרטורים

מאקרו בלי סוגריים נכשל בשתי חזיתות: מבפנים, כשארגומנט מכיל אופרטור חלש כמו + (למשל n + 2), ומבחוץ, כשצמוד לקריאת המאקרו אופרטור חזק יותר כמו *. עטיפת הגוף בלבד (x * x) מגינה רק מבחוץ ומשאירה את הארגומנט חשוף (n + 2 * n + 2).

סוגריים סביב כל הופעה של פרמטר ועוד זוג סביב הגוף כולו, כמו ב-#define SQR_OK(x) ((x) * (x)). אבל גם בלי הסוגריים התוצאה לעתים זהה, ולכן אין לנחש: בכל שאלה כותבים את ההרחבה ומחשבים אותה.

הגדרת מאקרושימוש (n = 4)טקסט מורחבתוצאה
SQR_BAD(x) x * xSQR_BAD(n + 2)n + 2 * n + 214 (במקום 36)
SQR_OUTER(x) (x * x)SQR_OUTER(n + 2)(n + 2 * n + 2)14
SQR_OK(x) ((x) * (x))SQR_OK(n + 2)((n + 2) * (n + 2))36
PROD_BAD(a, b) a * bPROD_BAD(3 + 2, 5)3 + 2 * 513 (במקום 25)
PROD_BAD(a, b) a * bPROD_BAD(5, 3 + 2)5 * 3 + 217
SUM_BAD(a, b) a + b4 * SUM_BAD(1, 3)4 * 1 + 37 (במקום 16)
SUM_OK(a, b) ((a) + (b))4 * SUM_OK(1, 3)4 * ((1) + (3))16
SUM_BAD(a, b) a + bSUM_BAD(3 * 4, 2)3 * 4 + 214 (כאן אין הבדל)
תרחיש 9: הדגמת המקרים בתוכנית מקומפלת
C
#include <stdio.h>
#define SQR_BAD(x) x * x
#define SQR_OUTER(x) (x * x)
#define SQR_OK(x) ((x) * (x))
#define PROD_BAD(u, v) u * v
#define SUM_BAD(u, v) u + v
#define SUM_OK(u, v) ((u) + (v))

int main(void) {
    int n = 4;
    printf("%d %d %d\n", SQR_BAD(n + 2), SQR_OUTER(n + 2), SQR_OK(n + 2));
    printf("%d %d\n", PROD_BAD(3 + 2, 5), PROD_BAD(5, 3 + 2));
    printf("%d %d %d\n", 4 * SUM_BAD(1, 3), 4 * SUM_OK(1, 3), SUM_BAD(3 * 4, 2));
    return 0;
}
פלט
14 14 36
13 17
7 16 14

בשורה הראשונה 4 + 2 * 4 + 2 = 14, ורק SQR_OK מחזיר 36. בשורה השנייה הכפל נצמד לגורם הסמוך (2 * 5 או 5 * 3), ובשורה השלישית רק SUM_OK מונע מ-4 להכפיל את 1 בלבד.

תרחיש 10: ארגומנט ביטוי במאקרו תנאי מוגן
C
#include <stdio.h>
#define ROUTE(x) ((x) % 5 == 0 ? (x) / 5 : (x) + 20)

int main(void) {
    int base = 9;
    int res = ROUTE(base + 1);
    printf("%d\n", res);
    return 0;
}
פלט
2

הסוגריים סביב x מאחדים את base + 1 ל-10. מכיוון ש-10 % 5 == 0 מתקיים, נבחר הענף 10 / 5 = 2.

ללא סוגריים סביב x, התנאי היה base + 1 % 5 == 0 (כלומר 9 + 1 == 0, שקר), והתוצאה הייתה 9 + 1 + 20 = 30.

טעויות נפוצות
  • סוגריים סביב הגוף כולו מספיקים כדי לתקן כל בעיית קדימות במאקרו. הם מגינים רק מפני אופרטורים חיצוניים, ולא מונעים פירוק של ארגומנט כמו n + 2.
  • מאקרו ללא סוגריים תמיד נותן תוצאה שגויה. כאשר קדימות האופרטורים ממילא תואמת (כמו SUM_BAD(3 * 4, 2)), התוצאה זהה, ולכן תמיד מרחיבים ומחשבים.
  • SQR_BAD(n + 2) מחשב תמיד את הריבוע של n + 2. בלי סוגריים סביב הפרמטר מתבצע הכפל הפנימי לפני החיבורים.
בדקו את עצמכם
נתון #define CUBE_BAD(x) x * x * x. מה הערך של CUBE_BAD(3 + 1)?

10, כי ההרחבה היא 3 + 1 * 3 + 1 * 3 + 1, כלומר 3 + 3 + 3 + 1.

איך מתקנים את CUBE_BAD כדי שיחזיר 64?

#define CUBE_OK(x) ((x) * (x) * (x)).

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

מאקרו שמשנה את המשתנה עצמו

נתחיל מהשורה שנוצרת אחרי הרחבת EXCHANGE(first, second) בתרחיש שלמטה: בגוף שלה כתובים first ו-second עצמם, לא עותקים שלהם. לכן כל מה שהגוף עושה להם נעשה למשתנים של הקורא.

בפונקציה רגילה הפרמטר הוא עותק של הארגומנט (העברה לפי ערך, call by value), ולכן שינוי בתוכה אינו נראה אחרי החזרה. מאקרו מעביר את הטקסט של השם עצמו, כך ש-++, --, השמה או פעולת ביטים מורכבת בגוף שלו פועלים על המשתנה של הקורא.

עוד הבחנה שכדאי לשמור: ב---v ההפחתה קודמת, ולכן מתקבל הערך המופחת, וב-v-- מתקבל הערך שהיה לפני ההפחתה.

תרחיש 11: קריאות חוזרות למאקרו שמפחית משתנה
C
#include <stdio.h>
#define STEP_BACK(v) (--v)

int main(void) {
    int idx = 12;
    int x = STEP_BACK(idx);
    int y = STEP_BACK(idx) + 5;
    printf("%d %d %d\n", x, y, idx);
    return 0;
}
פלט
11 15 10

הקריאה הראשונה מתרחבת ל-(--idx) שמורידה את idx ל-11 ונותנת 11. השנייה מתרחבת ל-(--idx) + 5, מורידה את idx ל-10 ומחשבת 10 + 5 = 15.

תרחיש 12: החלפת משתנים והדלקת/כיבוי ביטים דרך מאקרו
C
#include <stdio.h>
#define EXCHANGE(lhs, rhs) { int hold_ = (lhs); (lhs) = (rhs); (rhs) = hold_; }
#define FLAG_SET(r, bit) ((r) |= (1u << (bit)))
#define FLAG_CLR(r, bit) ((r) &= ~(1u << (bit)))

static void copy_swap(int p, int q) { int hold = p; p = q; q = hold; }

int main(void) {
    int first = 4, second = 9;
    copy_swap(first, second);
    printf("%d %d\n", first, second);
    EXCHANGE(first, second);
    printf("%d %d\n", first, second);

    unsigned char status = 0x08;
    FLAG_SET(status, 2);
    printf("%02X\n", status);
    FLAG_CLR(status, 3);
    printf("%02X\n", status);
    return 0;
}
פלט
4 9
9 4
0C
04

הפונקציה copy_swap החליפה רק את העותקים המקומיים שלה, ואילו EXCHANGE יצר בלוק שפעל ישירות על first ו-second. בהמשך, 1u << 2 (0x04) נדלק ב-0x08 ונותן 0x0C, וכיבוי ביט 3 (~(1u << 3)) משאיר 0x04.

טעויות נפוצות
  • --v מחזיר את הערך שלפני ההפחתה. האופרטור לפני המשתנה (--v) מפחית תחילה ומחזיר את הערך המעודכן; v-- מחזיר את הערך הישן.
  • ארגומנט של מאקרו מועתק לפי ערך כמו בפונקציה, ולכן אינו יכול להשתנות. המאקרו מדביק את מזהה המשתנה עצמו לתוך הקוד, כך שכל השמה או ++ פועלות על המשתנה המקורי.
בדקו את עצמכם
נתונים #define BUMP5(v) (v += 5) ו-int n = 2;. מה ידפיס printf("%d %d %d", a, b, n) אחרי int a = BUMP5(n); ו-int b = BUMP5(n) * 2;?

7 24 12. הקריאה הראשונה מעלה את n ל-7, והשנייה מעלה ל-12 ומכפילה ב-2.

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

ארגומנט שמחושב פעמיים

כשפרמטר מופיע בגוף המאקרו יותר מפעם אחת, ההצבה מעתיקה את הארגומנט בכל אחד מהמקומות, וכל תופעת לוואי שבו (למשל i++) יכולה לקרות כמה פעמים. צריך להפריד בין שני מצבים: חישוב כפול שהשפה מגדירה היטב, לבין התנהגות לא מוגדרת (undefined behavior), שבה השפה אינה מבטיחה תוצאה כלל.

ב-#define PICK_MAX(a, b) ((a) > (b) ? (a) : (b)) הפרמטר a מופיע פעמיים, בתנאי ובענף הראשון, והאופרטור ?: מסיים את חישוב התנאי (כולל ה-i++ שבו) לפני שהוא עובר לענף, ולכן אין סתירה בין שני השינויים. כשנבחר a המשתנה גדל פעמיים (מוגדר היטב אך מפתיע), וכשנבחר b הוא גדל פעם אחת בלבד.

הצד הבעייתי: #define SQR_OK(x) ((x) * (x)). הקריאה SQR_OK(i++) נפרסת ל-((i++) * (i++)), שבה i משתנה פעמיים בלי נקודת רצף בין השינויים. אין כאן ערך נכון: לשפה אין תשובה, וכל מהדר רשאי לתת ערך אחר.

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

תרחיש 13: i++ במאקרו מקסימום, ערך מוחלט והופעה יחידה
C
#include <stdio.h>
#define PICK_MAX(a, b) ((a) > (b) ? (a) : (b))
#define ABS_NUM(x) ((x) < 0 ? -(x) : (x))
#define MUL10(x) ((x) * 10)

int main(void) {
    int p = 12, q = 5;
    int r1 = PICK_MAX(p++, q);
    printf("%d %d\n", r1, p);

    int r = 3, s = 9;
    int r2 = PICK_MAX(r++, s);
    printf("%d %d\n", r2, r);

    int neg = -7;
    int r3 = ABS_NUM(neg++);
    printf("%d %d\n", r3, neg);

    int u = 4;
    int r4 = MUL10(u++);
    printf("%d %d\n", r4, u);
    return 0;
}
פלט
13 14
9 4
6 -5
40 5
ביטויתנאיענף נבחרתוצאהמצב המשתנה בסיום
PICK_MAX(p++, q)12 > 5 אמת, p עולה ל-13(p++) מחזיר 13, p עולה ל-1413p = 14
PICK_MAX(r++, s)3 > 9 שקר, r עולה ל-4(s) מחזיר 99r = 4
ABS_NUM(neg++)-7 < 0 אמת, neg עולה ל--6-(neg++) נותן -(-6) = 6, neg עולה ל--56neg = -5
MUL10(u++)מופע יחיד: ((u++) * 10) = 4 * 10-40u = 5
טעויות נפוצות
  • PICK_MAX(p++, q) הוא התנהגות לא מוגדרת. לאופרטור ?: יש נקודת רצף בין התנאי לענף הנבחר, ולכן סדר ההגדלות מוגדר לחלוטין.
  • לביטוי SQR_OK(i++) יש ערך מוגדר שאפשר לחשב במעקב. הביטוי ((i++) * (i++)) משנה את i פעמיים בלי נקודת רצף ביניהן, ולכן זו התנהגות לא מוגדרת.
  • מאקרו מעריך כל ארגומנט פעם אחת בלבד, כמו פונקציה. כל הופעה של הפרמטר בגוף המאקרו מדביקה ומבצעת את הארגומנט מחדש.
בדקו את עצמכם
נתונים #define PICK_MIN(a, b) ((a) < (b) ? (a) : (b)) ו-int i = 4, j = 9;. מה יהיו ערכי m ו-i אחרי int m = PICK_MIN(i++, j);?

m יהיה 5 ו-i יהיה 6, כי התנאי 4 < 9 מתקיים ו-i++ רץ שוב בענף.

ומה יהיו הערכים אם בהתחלה i = 12?

m יהיה 9 ו-i יהיה 13, כי התנאי שקרי ונבחר j.

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

האופרטורים # ו-##

אם PORT מוגדר כ-8080 ו-S(x) מוגדר כ-#x, אפשר לצפות ש-S(PORT) ייתן "8080". בפועל מתקבל "PORT". האופרטורים # ו-## מותרים רק בגוף מאקרו, וארגומנט שנוגע באחד מהם נשאר בדיוק כפי שנכתב, בלי הרחבה, וזו היוצאת מן הכלל של הסדר שתואר קודם.

קריאההאם PORT מורחב לפני #התוצאה
S(PORT)לא: הפרמטר נוגע ב-#"PORT"
XS(PORT) כש-XS(x) מוגדר כ-S(x)כן: בגוף של XS הפרמטר אינו נוגע ב-#, ולכן מורחב ל-8080 לפני שנמסר ל-S"8080"

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

  • #param (הפיכה למחרוזת, stringification): הארגומנט נעטף במרכאות והופך לליטרל. מותר להעביר כמה מילים יחד, למשל S(alpha beta); רווחי קצה נמחקים, וכל רצף רווחים פנימי הופך לרווח אחד.
  • a##b (הדבקת אסימונים, token pasting): אסימון (token) הוא יחידת קוד כמו מילה: שם, מספר או אופרטור. האופרטור מצמיד שני אסימונים לאסימון אחד, שהוא שם רגיל בקוד (משתנה או פונקציה) ולא מחרוזת.
  • מחרוזות ומרכאות: שם מאקרו שכתוב בתוך מרכאות נשאר כמות שהוא. מחרוזות שכתובות זו ליד זו, כמו "hi" "!", מאוחדות על ידי המהדר ל-"hi!", וזו הסיבה ש-printf(#v " => %d\n", v) מקבל מחרוזת פורמט אחת.
תרחיש 14: מחרוזת, הדבקת מזהים ומעטפת דו-שלבית
C
#include <stdio.h>
#define S(x) #x
#define XS(x) S(x)
#define PORT 8080
#define CONCAT(a, b) a##b
#define LOG_VAL(v) printf(#v " => %d\n", v)

int main(void) {
    int max_conn = 24;
    printf("%s|%s|%s\n", S(  alpha   beta ), S(PORT), XS(PORT));
    printf("%d\n", CONCAT(max_, conn));
    LOG_VAL(max_conn);
    printf("%s\n", "PORT");
    printf("%s\n", "hi" "!");
    return 0;
}
פלט
alpha beta|PORT|8080
24
max_conn => 24
PORT
hi!

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

C
printf("%s|%s|%s\n", "alpha beta", "PORT", "8080");
printf("%d\n", max_conn);
printf("max_conn" " => %d\n", max_conn);
printf("%s\n", "PORT");
printf("%s\n", "hi" "!");

המאקרו CONCAT בנה את שם המשתנה max_conn עצמו, ולכן %d הדפיס את ערכו (24). %s הדפיס את כל המחרוזות ללא הגרשיים.

טעויות נפוצות
  • S(PORT) מחזיר "8080" ישירות. ארגומנט של # אינו מורחב לפני ההפיכה למחרוזת, ולכן מתקבל "PORT".
  • CONCAT(x, y) עם ## יוצר מחרוזת שמדפיסה xy. האופרטור ## מחבר אסימונים לשם מזהה בקוד, כמו שם של משתנה או פונקציה.
  • S(alpha beta) גורם לשגיאת קומפילציה או לוקח רק את המילה הראשונה. כל הארגומנט עד הפסיק או הסוגר הופך למחרוזת אחת עם רווח בודד בין המילים.
  • הדפסת S(abc) עם %s מציגה "abc" עם גרשיים. הגרשיים רק תוחמים את ליטרל המחרוזת בקוד המקור ואינם מודפסים.
בדקו את עצמכם
נתונים #define STRFY(x) #x, #define GLUE_ID(a, b) a##b ו-int k78 = 15;. מה ידפיס printf("%s %d\n", STRFY( k7 8 ), GLUE_ID(k7, 8));?

k7 8 15, כי STRFY מצמצם לרווח אחד ("k7 8") ו-GLUE_ID מרכיב את המזהה k78 שערכו 15.

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

מאקרו מרובה שורות ו-do { } while (0)

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

  1. כמה פקודות אחרי if בלי {}: אחרי ההרחבה מתקבל if (c) a(); b();, ורק a() שייכת ל-if, ואילו b() מתבצעת תמיד. עם -Wall מדפיס gcc אזהרה בנוסח macro expands to multiple statements.
  2. גוף בתוך { ... } לפני else: הקריאה נכתבת עם ; בסוף, ולכן אחרי ההרחבה נוצר if (c) { ... } ; else .... הפקודה הריקה ; סוגרת את ה-if, וה-else נשאר בלי בן זוג, ומתקבלת שגיאת קומפילציה.
  3. גוף עם ; בתוך ביטוי: כשמאקרו כזה מופיע כארגומנט של printf, ה-; נכנס לתוך הסוגריים של הקריאה, וזה אינו תחביר חוקי, כך שהקומפילציה נכשלת.

גוף של כמה פקודות עוטפים ב-do { body } while (0), בלי ; בסוף ההגדרה. בלולאת do התנאי נבדק רק אחרי הסיבוב הראשון, ולכן הגוף רץ בדיוק פעם אחת. המבנה כולו הוא פקודה אחת ממש, ו-; שהקורא כותב אחריו משלים אותה, כך שהמאקרו נכנס אחרי if ולפני else בלי בעיה.

תרחיש 15: שתי פקודות אחרי if מול עטיפת do { } while (0)
C
#include <stdio.h>
#define LOG2(v) printf("val=%d ", v); printf("end ")
#define LOG2_OK(v) do { printf("val=%d ", v); printf("end "); } while (0)

int main(void) {
    int enabled = 0;
    if (enabled)
        LOG2(7);
    printf("| ");
    if (enabled)
        LOG2_OK(7);
    else
        printf("off ");
    printf("| fin\n");
    return 0;
}
פלט
end | off | fin

ב-if הראשון רק printf("val=%d ", 7); תלוי ב-enabled ומדולג, בעוד printf("end "); רץ תמיד. ב-if השני כל גוף LOG2_OK הוא פקודה אחת, ולכן הענף else מתבצע.

תרחיש 16: שתי דוגמאות שאינן מתקמפלות

כל אחת מהתוכניות הבאות נשמרה בקובץ main.c וקומפלה בנפרד עם gcc -c main.c. הפלט המוצג הוא הטקסט המלא כפי ש-gcc 16 הדפיס אותו; בגרסאות אחרות הניסוח עשוי להיות שונה מעט.

C
#define CLEAR_V(v) { v = 0; }

int main(void) {
    int x = 3;
    if (x > 0)
        CLEAR_V(x);
    else
        x = 1;
    return 0;
}
פלט
main.c: In function 'main':
main.c:7:5: error: 'else' without a previous 'if'
    7 |     else
      |     ^~~~

השורה CLEAR_V(x); הופכת ל-{ x = 0; } ;, והנקודה-פסיק המיותרת מפרידה בין ה-if ל-else.

C
#include <stdio.h>
#define PAIR_VAL(p1, p2) (p1); (p2);

int main(void) {
    int u = 1, v = 2;
    printf("%d\n", PAIR_VAL(u, v));
    return 0;
}
פלט
main.c: In function 'main':
main.c:2:30: error: expected ')' before ';' token
    2 | #define PAIR_VAL(p1, p2) (p1); (p2);
      |                              ^
main.c:6:20: note: in expansion of macro 'PAIR_VAL'
    6 |     printf("%d\n", PAIR_VAL(u, v));
      |                    ^~~~~~~~
main.c:6:11: note: to match this '('
    6 |     printf("%d\n", PAIR_VAL(u, v));
      |           ^

gcc מצביע על ה-; שבתוך ההגדרה, והערות ה-note מראות איפה המאקרו הורחב ואיזה סוגר ציפה לסגירה.

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

טעויות נפוצות
  • לולאת do { ... } while (0) אינה מבצעת את הגוף שלה אף פעם כי התנאי הוא 0. בלולאת do-while הגוף רץ קודם ורק בסוף נבדק התנאי, ולכן הוא רץ בדיוק פעם אחת.
  • אם תנאי ה-if שקרי, כל הפקודות של המאקרו שאחריו מדולגות. ללא {} או do { } while (0), ה-if שולט רק בפקודה הראשונה מתוך ההרחבה.
  • מאקרו עם כמה פקודות מופרדות ב-; מחזיר את הפקודה האחרונה כששמים אותו בביטוי. נוכחות של ; בתוך ביטוי כמו ארגומנט של printf היא שגיאת תחביר בקומפילציה.
בדקו את עצמכם
נתונים #define ADD_TWICE(v) v++; v++ ו-int n = 1;. מה ערכו של n אחרי if (n > 20) ADD_TWICE(n);?

2, כי רק ה-n++ הראשון שייך ל-if (ומדולג), והשני מתבצע בכל מקרה.

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

typedef מול #define, ו-inline מול מאקרו

למרות שלעתים מנסים להשתמש ב-#define ככינוי לטיפוס, הוא אינו שקול ל-typedef. typedef מגדיר טיפוס אמיתי שהמהדר מכיר: ב-typedef char *BytePtr; BytePtr p3, p4; שני המשתנים הם מצביעים.

לעומת זאת, #define BYTE_PTR char * עם BYTE_PTR p1, p2; מתרחב ל-char * p1, p2;. כמו בכל הצהרת C, הכוכבית שייכת למשתנה שאחריה (p1) בלבד, ולכן p2 הוא char פשוט.

כשרוצים את המהירות של מאקרו בלי המלכודות שלו (ארגומנט שמחושב כמה פעמים, העדר בדיקת טיפוסים), כותבים פונקציית static inline. המילה inline היא הצעה למהדר ולא פקודה, והיא אינה משנה את התוצאה; הטבלה מסכמת את ההבדלים.

מאפייןמאקרו עם פרמטריםפונקציה (כולל static inline)
בדיקת טיפוסיםאין בדיקה; אותו גוף מתאים לכל טיפוס שהביטוי מתאים לוכל ארגומנט נבדק ומומר לטיפוס הפרמטר
כמה פעמים מחושב ארגומנטכמספר ההופעות של הפרמטר בגוףפעם אחת בכל קריאה
שינוי משתנה של הקוראאפשרי, כי השם עצמו מוצב בקודלא ישירות, כי הפרמטר הוא עותק
תחום הכרה (scope)אין תחום; ההגדרה נמשכת עד #undef או עד סוף הקובץכללי ה-scope הרגילים של השפה
ניפוי שגיאות וכתובתאין למאקרו סמל משלו, ולכן אין בו מה לעצור או להיכנס אליו, ואי אפשר לקחת כתובת. הדיבאגר מציג בדרך כלל את שורות המקור עם הקריאה למאקרו, ורק עם מידע מאקרו (למשל -g3) הוא יכול להציג אותויש לה שם, אפשר לעצור בה ואפשר לקחת את כתובתה
תרחיש 17: מצביעי #define מול typedef, וחלוקה במאקרו מול inline
C
#include <stdio.h>
#define BYTE_PTR char *
typedef char *BytePtr;

#define QUARTER_M(x) ((x) / 4)
static inline int quarter_f(int x) { return x / 4; }

int main(void) {
    BYTE_PTR p1, p2;
    BytePtr p3, p4;
    printf("%zu %zu %zu %zu\n", sizeof(p1), sizeof(p2), sizeof(p3), sizeof(p4));
    printf("%.2f %d\n", QUARTER_M(9.0), quarter_f(11.9));
    return 0;
}
פלט
8 1 8 8
2.25 2

המשתנים p1, p3 ו-p4 הם מצביעים (8 בתים), ואילו p2 הוא char (1 בית). המאקרו QUARTER_M(9.0) מחלק double ב-4 ומחזיר 2.25, בעוד quarter_f(11.9) מקבל int ולכן 11.9 נקצץ ל-11 בכניסה, ו-11 / 4 נותן 2.

טעויות נפוצות
  • המילה inline מחייבת את המהדר להדביק את גוף הפונקציה בכל נקודת קריאה. זו המלצה בלבד, והמהדר חופשי להשאיר קריאה רגילה לפונקציה.
  • #define PTR int * זהה בהתנהגותו ל-typedef int *PTR. בהצהרת כמה משתנים בשורה עם #define, הכוכבית תופסת רק למשתנה הראשון.
  • פונקציית inline פועלת על כל טיפוס בלי המרה, בדומה למאקרו. כל ארגומנט מומר אוטומטית לטיפוס הפרמטר שהוגדר בחתימת הפונקציה.
בדקו את עצמכם
נתונים #define SPTR short * ו-SPTR a, b;. מה הערך של sizeof(b) ב-Linux x86-64?

2, משום שהשורה מתרחבת ל-short * a, b;, כך ש-b הוא short רגיל ולא מצביע.

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

enum: רשימות קבועים שלמים בשם

כללי הספירה והקצאת הערכים

בקוד שמטפל במצבי תהליך קל להיתקע עם מספרים חשופים: האם 2 אומר כישלון או אזהרה? enum פותר את זה בכך שהוא נותן שם לכל מספר שלם, לדוגמה enum Status { OK, WARN, FAIL };, וכך הקוד נקרא במילים ולא בספרות שרירותיות.

כדי לחשב את הערכים בלי לטעות, דמיינו מונה שעובר על הרשימה משמאל לימין. הוא מתחיל ב-0, כל שם לוקח את הערך הנוכחי שלו, ואז המונה עולה ב-1. כשליד שם כתוב = n, המונה מוחלף ב-n, והשם לוקח אותו; מכאן הספירה נמשכת מ-n + 1, ולא לפי המקום של השם ברשימה.

תרחיש 18: קביעת ערכים עם דילוגים, שליליים וכפילויות
C
#include <stdio.h>
enum Priority { P_LOW, P_MED, P_HIGH = 7, P_URGENT, P_CRIT = 12 };
enum Balance { DEBT = -4, FEE, LOW_B = -1, BONUS = 3, EXTRA = 3, TOP_B };

int main(void) {
    printf("prio: %d %d %d %d %d\n", P_LOW, P_MED, P_HIGH, P_URGENT, P_CRIT);
    printf("bal: %d %d %d %d %d %d\n", DEBT, FEE, LOW_B, BONUS, EXTRA, TOP_B);
    return 0;
}
פלט
prio: 0 1 7 8 12
bal: -4 -3 -1 3 3 4
מזההאופן החישובתוצאה
P_LOWהמונה בתחילת הרשימה0
P_MED0 ועוד 11
P_HIGH= 7 מציב את המונה ל-77
P_URGENT7 ועוד 18
P_CRIT= 12 מציב מחדש12
DEBTהצבה של מספר שלילי-4
FEE-4 ועוד 1-3
LOW_Bהצבה שלילית נוספת-1
BONUSהצבה מפורשת3
EXTRAהצבה של אותו ערך: שני שמות על מספר אחד3
TOP_B3 ועוד 14

בטבלה רואים גם שהמונה אינו מוגבל למספרים חיוביים: ב-Balance הוא נפתח ב--4, ולכן FEE מקבל -3. שני שמות יכולים לשבת על אותו ערך (BONUS ו-EXTRA), והשם שאחריהם, TOP_B, ממשיך מהערך המשותף ועוד 1.

טעויות נפוצות
  • הספירה ב-enum מתחילה תמיד מ-1. בהיעדר ערך מפורש, האיבר הראשון מקבל דווקא 0.
  • קבוע ללא ערך ממשיך לפי המספר הסידורי שלו ברשימה. כל קבוע בלי ערך מפורש מחושב כערך הקבוע שלפניו ועוד 1, גם אם הייתה קפיצה באמצע.
  • קבוע שמופיע מיד אחרי ערך מפורש שווה לאותו ערך. הוא גדול ממנו ב-1, לא שווה לו.
  • הערך של קבוע נקבע לפי אורך הרשימה כולה. כמות האיברים ב-enum אינה משפיעה על ערכו של אף קבוע.
בדקו את עצמכם
מהם הערכים של enum { K1 = 4, K2, K3 = 2, K4 };?

K1 הוא 4, K2 הוא 5, K3 הוא 2 ו-K4 הוא 3.

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

enum כטיפוס שלם, גודל ותחום הכרה

קבוע של enum הוא פשוט מספר int עם שם, וגם משתנה מסוג enum מחזיק בפועל מספר שלם. לכן enum תופס ב-gcc על x86-64 בדיוק 4 בתים, בין אם ברשימה שלושה קבועים ובין אם שלושים (הדגל -fshort-enums משנה זאת).

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

בנוסף, המהדר אינו בודק שמה שנכנס למשתנה enum מופיע ברשימה: enum Mode m = 25; מתקמפל, ו-m מחזיק 25. עם זאת, שמות הקבועים כפופים לכללי תחום ההכרה (scope), ולכן שני enum באותו תחום לא יכולים להשתמש באותו שם.

שימו לב להפרדה בין שלבי התרגום: המעבד המקדים רץ לפני שהמהדר מנתח הגדרות enum, ולכן תנאי #if אינו מכיר את הקבועים הללו ומתייחס אליהם כאל 0.

תרחיש 19: ערך מחוץ לרשימה, קבועים בשימושים שלמים וגודל
C
#include <stdio.h>
enum Size { S_SMALL = 2, S_BIG = 6 };

int main(void) {
    int slots[S_BIG];
    enum Size pick = 30;
    printf("%d %d\n", pick, pick > S_BIG);
    printf("%zu %zu\n", sizeof(slots) / sizeof(slots[0]), sizeof(enum Size));
    switch (S_SMALL + 1) {
    case S_SMALL + 1: printf("three\n");
    }
    return 0;
}
פלט
30 1
6 4
three

pick הוא מספר שלם רגיל, ולכן הוא מחזיק 30 אף ש-30 אינו אחד הקבועים, וההשוואה 30 > 6 נותנת 1. S_BIG שימש כגודל מערך (6 תאים) ו-S_SMALL + 1 כתווית case, כי אלה קבועים שלמים. sizeof(enum Size) הוא 4.

טעויות נפוצות
  • השמת מספר שאינו ברשימה למשתנה enum נכשלת בהידור או מוחלפת בקבוע חוקי. השפה אינה מבצעת בדיקת טווח ושומרת את המספר כפי שהוא.
  • ל-enum של שלושה קבועים גודל של בית אחד או של שלושה בתים. תחת gcc על x86-64 הגודל הוא 4 בתים כברירת מחדל.
  • במערכת 64 סיביות כל enum גדל ל-8 בתים. הוא נשאר בגודל int, כלומר 4 בתים.
בדקו את עצמכם
נתונים enum Dir { UP = 1, DOWN = -1 }; ו-enum Dir d = 7;. מה יודפס מ-printf("%d %d", d, d * DOWN)?

יודפס 7 -7, כי d שומר את 7 כמו שהוא ו-DOWN הוא המספר -1.

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

struct: אגודת שדות באובייקט אחד

הגדרה, אתחול וגישה לשדות

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

C
struct Parcel {
    char zone[3];
    int pieces;
    int fee;
};

שם הטיפוס המלא הוא struct Parcel: בלי typedef, המילה struct היא חלק מהשם בכל שימוש.

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

כתיבהאיך הערכים מתחלקיםשדות שלא נכתבו
{ {'Q','R','5'}, 6, 40 }לפי סדר השדות בהגדרה; שדה שהוא מערך מקבל סוגריים פנימיים משלואין כאלה
{ .fee = 25, .pieces = 3 }לפי שם השדה (designated initializer), והסדר בכתיבה חופשימקבלים 0
{ 0 }רק הערך הראשון נכתבכל השאר מקבלים 0, ולכן זו הדרך לאפס מבנה שלם

מערך char אפשר לאתחל גם ישירות ממחרוזת ליטרלית, כמו char zone[4] = "QR5";, אבל אז חייב להישאר מקום לתו הסיום '\0'.

לשדה ניגשים עם נקודה כשיש משתנה (b.pieces) ועם חץ כשיש מצביע אליו (p->pieces, שהוא קיצור של (*p).pieces). שדות int מתנהגים כמו כל int, כך ש-+= ו-* פועלים עליהם כרגיל.

שימו לב: zone שמולא בשלושה תווים בלי מקום ל-'\0' אינו מחרוזת. מדפיסים אותו תו אחר תו עם %c, כי %s ימשיך לקרוא אל מעבר לסוף המערך והתוצאה בלתי מוגדרת.

תרחיש 20: שלוש צורות אתחול, מצביע ושדה שהושמט
C
#include <stdio.h>
struct Parcel {
    char zone[3];
    int pieces;
    int fee;
};

int main(void) {
    struct Parcel a = { {'Q', 'R', '5'}, 6, 40 };
    struct Parcel b = { .fee = 25, .pieces = 3 };
    struct Parcel z = { 0 };
    struct Parcel *p = &b;
    p->pieces += a.pieces * 3;
    printf("%c%c%c %d %d\n", a.zone[0], a.zone[1], a.zone[2], a.pieces, a.fee);
    printf("%d %d %d\n", b.pieces, (*p).fee, b.zone[0]);
    printf("%d %d %d\n", z.pieces, z.fee, z.zone[2]);
    return 0;
}
פלט
QR5 6 40
21 25 0
0 0 0

בשורה הראשונה כל %c מדפיס תו בודד, ולכן שלושת התווים יוצאים צמודים. p מצביע על b, ולכן p->pieces += a.pieces * 3 מוסיף 18 ל-3 ו-b.pieces נהיה 21; (*p).fee הוא אותו שדה כמו b.fee. ל-b לא נכתב zone, ולכן b.zone[0] הוא 0, ואצל z הכול אפס.

טעויות נפוצות
  • החיבור v.dx + v.dy עבור 2 ו-3 מפיק 23. האופרטור + מחבר שני ערכי int אריתמטית, והתוצאה היא 5.
  • רשימת האתחול {9, 4} מאתחלת מהשדה האחרון לראשון. השיבוץ מתבצע תמיד לפי סדר הכתיבה בהגדרת ה-struct, מההתחלה לסוף.
  • כדי לדעת מה יודפס משדה של struct, יש לחשב קודם את sizeof שלו. הדפסת ערך של שדה תלויה רק בערך שאוחסן בו, לא בגודל המבנה בזיכרון.
חזרה לתוכן העניינים

העתקה של struct לעומת שדות מצביעים

כל פעולה שמשכפלת struct - השמה עם =, שליחה לפונקציה לפי ערך או החזרה מפונקציה - מבצעת שכפול בית-אחר-בית של גוש הזיכרון, בדומה לקריאה memcpy(&b, &a, sizeof a). בעקבות זאת, לאחר struct Pair b = a; מתקבל עותק עצמאי לחלוטין, ושינויים ב-b אינם משנים את a.

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

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

תרחיש 21: העתקה דרך פרמטר ודרך השמה
C
#include <stdio.h>
struct Badge {
    char label[6];
    int level;
    int *visits;
};

static void touch(struct Badge g) {
    g.label[0] = 'X';
    g.level = 99;
    *g.visits += 5;
}

int main(void) {
    int visits = 2;
    struct Badge a = { "delta", 1, &visits };
    touch(a);
    printf("%s %d %d\n", a.label, a.level, visits);
    struct Badge b;
    b = a;
    b.label[4] = '!';
    b.level = 7;
    printf("%s %d | %s %d\n", a.label, a.level, b.label, b.level);
    return 0;
}
פלט
delta 1 7
delta 1 | delt! 7

הפונקציה touch קיבלה עותק שלם של a, ולכן השינוי ב-g.label[0] וב-g.level נעלם יחד עם העותק. רק *g.visits += 5 נשאר: העותק החזיק את הכתובת של visits, ולכן המשתנה המקורי עלה מ-2 ל-7. אחרי b = a, שינוי בשם או במספר של b אינו נוגע ב-a.

טעויות נפוצות
  • ההשמה b = a הופכת את b לכינוי המצביע לאותו מבנה. ב-C השמת struct יוצרת עותק נפרד בזיכרון.
  • אחרי העתקה, שני המבנים חולקים מערך שמוגדר בתוכם. רק שדה מצביע משותף בין העותקים; מערך מוטמע מועתק כולו.
בדקו את עצמכם
נתון struct Pack { int v[3]; int w; } a = {{1, 2, 3}, 4}, b = a;. מה יודפס מ-printf("%d %d", a.v[2], b.v[2]) אחרי b.v[2] = 0;?

יודפס 3 0, כי המערך שבתוך b הוא עותק נפרד.

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

יישור, ריפוד וחישוב sizeof

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

טיפוס (gcc 64 סיביות, Linux; ב-Windows long הוא 4)גודל בבתיםיישור נדרש
char11
short22
int, float, enum44
long, double, מצביע88
מערך של N איברים מסוג TN * sizeof(T)היישור של T
struct או unionלפי כללי הריפודהיישור הגדול ביותר מבין שדותיו

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

  1. מתחילים בהיסט 0.
  2. לפני כל שדה מעגלים את ההיסט כלפי מעלה לכפולה הקרובה של היישור שלו; הבתים הריקים שדילגתם עליהם נקראים ריפוד (padding).
  3. מוסיפים את גודל השדה להיסט הנוכחי.
  4. בסיום מעגלים את הגודל הכולל כלפי מעלה לכפולה של היישור הגדול ביותר במבנה, כדי שגם במערך של מבנים כל איבר יתחיל בכתובת מיושרת.
תרחיש 22: שישה מבנים פשוטים, מבנים מקוננים ומבנה ארוז
C
#include <stdio.h>
#include <stddef.h>
struct M1 { short a; char b; };
struct M2 { char a; short b; int c; };
struct M3 { char a; double d; char e; };
struct M4 { double d; char a; char e; };
struct M5 { char name[5]; short s; };
struct M6 { int arr[3]; char c; };
struct Tri { char x; char y; char z; };
struct Frame { int id; struct Tri in; short s; };
struct Wide { double d; char c; };
struct Shell { char tag; struct Wide w; };
struct __attribute__((packed)) Compact { char k; int n; short w; };

int main(void) {
    printf("sizes: %zu %zu %zu %zu %zu %zu\n", sizeof(struct M1), sizeof(struct M2), sizeof(struct M3),
           sizeof(struct M4), sizeof(struct M5), sizeof(struct M6));
    printf("Frame: in@%zu s@%zu size %zu\n", offsetof(struct Frame, in), offsetof(struct Frame, s),
           sizeof(struct Frame));
    printf("Shell: w@%zu size %zu\n", offsetof(struct Shell, w), sizeof(struct Shell));
    printf("Compact: n@%zu w@%zu size %zu\n", offsetof(struct Compact, n), offsetof(struct Compact, w),
           sizeof(struct Compact));
    return 0;
}
פלט
sizes: 4 8 24 16 8 16
Frame: in@4 s@8 size 12
Shell: w@8 size 24
Compact: n@1 w@5 size 7
מבנהפריסה (היסט: שדה)גודל סופי
M10..1: a, 2: b, ריפוד סופי 34
M20: a, ריפוד 1, 2..3: b, 4..7: c8
M30: a, ריפוד 1..7, 8..15: d, 16: e, ריפוד סופי 17..2324
M40..7: d, 8: a, 9: e, ריפוד סופי 10..1516
M50..4: name, ריפוד 5, 6..7: s8
M60..11: arr, 12: c, ריפוד סופי 13..1516
Frame0..3: id, 4..6: in, ריפוד 7, 8..9: s, ריפוד סופי 10..1112
Shell0: tag, ריפוד 1..7, 8..23: w24
Compact (packed)0: k, 1..4: n, 5..6: w7

הפלט התקבל מ-gcc 16 (MinGW) על Windows 64 סיביות. מכיוון שאף מבנה כאן אינו משתמש ב-long, אותם גדלים והיסטים מתקבלים גם ב-Linux x86-64.

בתרחיש, מבנה שמוגדר בתוך מבנה אחר מתיישר לפי השדה המיושר ביותר שבתוכו, ולא לפי הגודל שלו. Tri הוא שלושה char: גודלו 3 והיישור שלו 1, ולכן בתוך Frame הוא מתחיל מיד בהיסט 4. לעומתו Shell מכיל את Wide, שיש בו double; הוא חייב להתחיל בכתובת שמתחלקת ב-8, ולכן לפניו נוצר ריפוד של 7 בתים.

M3 ו-M4 מכילים אותם שדות בדיוק, ובכל זאת הם תופסים 24 ו-16 בתים: סדר השדות משנה את כמות הריפוד. כלל אצבע הוא לסדר מהיישור הגדול לקטן, וכך הריפוד מצטבר רק בסוף. בכל מקרה sizeof של מבנה אינו קטן מסכום גדלי השדות.

כדי לא לספור ידנית משתמשים ב-offsetof(type, member) מ-<stddef.h>, שמחזיר את ההיסט של שדה. ב-gcc אפשר גם לסמן מבנה כ-__attribute__((packed)) ולוותר על הריפוד, כמו ב-Compact (n בהיסט 1, גודל 7); זו הרחבה לא תקנית, שב-x86 הופכת את הגישה הלא מיושרת לאיטית יותר, ובמעבדים אחרים עלולה להקריס את התוכנית.

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

ההיסט של c הוא 8 והגודל הכולל 12 (a ב-0, ריפוד 1..3, b ב-4..7, c ב-8..9, ריפוד סופי 10..11 לכפולה של 4).

מהו sizeof של struct { short s; double d; } ושל struct { int x; char y; char z; short w; }?

16 ו-8.

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

union: שמות שונים לאותם בתים

זיכרון משותף: הכתיבה האחרונה קובעת

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

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

תרחיש 23: שתי מדבקות על אותה מגירה
C
#include <stdio.h>
union Meter { int ticks; double volts; };

int main(void) {
    union Meter m;
    m.ticks = 9;
    m.volts = 2.25;
    printf("%.2f %d\n", m.volts, m.ticks);
    m.ticks = 31;
    printf("%d %zu\n", m.ticks, sizeof m);
    return 0;
}
פלט
2.25 0
31 8

ticks ו-volts מתחילים באותה כתובת. אחרי שכתבנו 2.25 ל-volts, ה-9 ששמרנו ב-ticks נדרס, ולכן קריאת ticks מציגה את ארבעת הבתים הנמוכים של 2.25 בזיכרון, ובמקרה הזה הם אפסים, כלומר 0. אחרי כתיבה חדשה ל-ticks הוא נקרא בדיוק כפי שנכתב, והגודל של כל ה-union הוא 8, כגודל השדה הגדול.

טעויות נפוצות
  • כל שדה ב-union שומר עותק נפרד של הערך שלו. הפרדה כזו קיימת ב-struct; ב-union כל השדות משתפים את אותם בתים.
  • אחרי כתיבה ל-v.f, קריאה של v.f מחזירה ערך זבל. השדה שנכתב אחרון נקרא תמיד בדיוק כפי שנכתב.
חזרה לתוכן העניינים

חישוב הגודל של union

נתחיל מדוגמה: union Msg { char text[10]; double d; int n; };. החיבור 10 + 8 + 4 = 22 שגוי, כי השדות חופפים ולא עומדים בשורה. מודדים שני דברים: השדה הרחב ביותר (text, 10 בתים) והיישור המחמיר ביותר (8, של double), ואז מעגלים את 10 לכפולה של 8, כלומר 16.

העיגול אינו קוסמטי: במערך של Msg האיבר השני מתחיל בדיוק אחרי 16 בתים, ולכן ה-double שבו ממשיך לשבת על כתובת שמתחלקת ב-8. בגודל 10 זה היה נשבר. אותו כלל חל על long: בלינוקס x86-64 יש לו 8 בתים והוא מיושר ל-8, כמו double (ב-Windows 64 סיביות הוא 4 בתים).

תרחיש 24: מדידת גודל של חמישה איחודים
C
#include <stdio.h>
union V1 { char tag[9]; short n; };
union V2 { int a[2]; char c; };
union V3 { char s[5]; long long big; };
union V4 { double d; char buf[17]; };
union V5 { short a; char b; };

int main(void) {
    printf("sizes: %zu %zu %zu %zu %zu\n", sizeof(union V1), sizeof(union V2), sizeof(union V3),
           sizeof(union V4), sizeof(union V5));
    return 0;
}
פלט
sizes: 10 8 8 24 2
איחודשדה גדול ביותריישור מרביתוצאה אחרי עיגול
V19 (tag)2 (short)9 עולה ל-10
V28 (a)4 (int)8 נשאר 8
V38 (big)8 (long long)8 נשאר 8
V417 (buf)8 (double)17 עולה ל-24
V52 (a)22 נשאר 2
טעויות נפוצות
  • הגודל של union הוא סכום הגדלים של כל שדותיו. השדות חופפים בזיכרון, ולכן הגודל נקבע לפי השדה הגדול ביותר והיישור המרבי.
  • הגודל שווה תמיד בדיוק לגודל השדה הגדול ביותר. יש לעגל כלפי מעלה לכפולה של היישור הגדול ביותר.
  • union של int ו-double תופס 16 בתים. 16 הוא גודל של struct עם אותם שדות; ב-union הגודל הוא 8.
בדקו את עצמכם
מהם הגדלים של union { char b[5]; short s; }, union { char b[13]; int i; } ו-union { int a[3]; char c; }?

6, 16 ו-12.

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

Little Endian: סידור הבתים בזיכרון

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

היסט כתובת+0+1+2+3
בית של 0x1A2B3C4D4D3C2B1A

כדי לדעת מה שדה רואה, התחילו מהכתובת הנמוכה וספרו את הבתים שהשדה מכסה. מערך של ארבעה בתים רואה לפי הסדר 4D 3C 2B 1A, כלומר bytes[0] הוא הבית הנמוך 4D; שדה short מכסה רק את +0 ו-+1, ולכן הוא 3C4D, ושדה char בודד מכסה רק את 4D.

אם כותבים bytes[3] = 0xEE, משתנה רק הבית שב-+3, ו-0x1A2B3C4D נהפך ל-0xEE2B3C4D. שאר הבתים נשארים כמות שהם.

לגבי סימן: בית מ-0x80 ומעלה נקרא כמספר שלילי אם קוראים אותו כ-char רגיל, שב-gcc על x86 הוא עם סימן. לכן 0xD4 הוא -44 דרך char ו-212 דרך unsigned char, ולעבודה עם בתים בטווח 0 עד 255 בוחרים ב-unsigned char. ב-Big Endian הסדר הפוך, אך הנושא כאן הוא x86-64.

תרחיש 25: בחינה ועדכון של בתים בודדים דרך union
C
#include <stdio.h>
union Raw32 {
    unsigned int u;
    unsigned char bytes[4];
    unsigned short s;
};

int main(void) {
    union Raw32 r;
    r.u = 0x1A2B3C4D;
    printf("%02X %02X %02X %02X | %X\n", r.bytes[0], r.bytes[1], r.bytes[2], r.bytes[3], r.s);
    r.bytes[3] = 0xEE;
    printf("%X\n", r.u);
    r.u = 0x145;
    printf("%c %d\n", r.bytes[0], r.bytes[1]);

    char sc = (char)0xD4;
    unsigned char uc = 0xD4;
    printf("%d %d\n", sc, uc);
    return 0;
}
פלט
4D 3C 2B 1A | 3C4D
EE2B3C4D
E 1
-44 212

בפלט, r.s הוא 3C4D ו-bytes[3] אחרי העדכון הוא EE, בדיוק כמו בחישוב למעלה.

עבור 0x145 הבית הנמוך הוא 0x45 (69, האות 'E') ואחריו מגיע 1. השורה האחרונה מראה את אותו בית 0xD4 בשתי פרשנויות: -44 ו-212.

טעויות נפוצות
  • ב-0x1234, האיבר c[0] מחזיק את הבית הגבוה 12. ב-Little Endian הבית הראשון בכתובת הנמוכה הוא הבית הנמוך, כלומר 34.
  • שדה short ב-union עם int קורא את החצי העליון. שניהם מתחילים בהיסט 0, ולכן ה-short קורא את שני הבתים הנמוכים.
  • עדכון של bytes[0] אינו משנה את ערך ה-int. הוא משנה בדיוק את הבית התואם בתוך ה-int.
  • קריאת 0xFF דרך unsigned char נותנת -1. unsigned char תמיד אי-שלילי ומחזיר 255; רק char עם סימן נותן -1.
בדקו את עצמכם
נתון union { unsigned int v; unsigned char c[4]; } u;. לאחר u.v = 0xAABBCCDD;, מה מדפיס printf("%X %X", u.c[0], u.c[3]), ומה ערכו של u.v אחרי u.c[1] = 0;?

יודפס DD AA. אחרי u.c[1] = 0;, הבית CC מתאפס ולכן u.v הופך ל-0xAABB00DD.

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

union מתויג (tagged union)

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

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

עוד פרט: אתחול של union בסוגריים מסולסלים בלי שם שדה מכניס את הערך לשדה הראשון שהוגדר. כדי לאתחל שדה אחר כותבים את שמו, למשל { .ratio = 0.5f }.

תרחיש 26: מערך של תאים עם תג
C
#include <stdio.h>
enum Kind { K_COUNT, K_RATIO, K_GRADE };
struct Cell {
    enum Kind kind;
    union { int count; float ratio; char grade; } u;
};

int main(void) {
    struct Cell cells[3] = {
        { K_COUNT, { 42 } },
        { K_RATIO, { .ratio = 0.5f } },
        { K_GRADE, { .grade = 'B' } }
    };
    for (int i = 0; i < 3; i++) {
        switch (cells[i].kind) {
        case K_COUNT: printf("count=%d ", cells[i].u.count); break;
        case K_RATIO: printf("ratio=%.2f ", cells[i].u.ratio); break;
        case K_GRADE: printf("grade=%c ", cells[i].u.grade); break;
        }
    }
    printf("| %c\n", cells[0].u.grade);
    return 0;
}
פלט
count=42 ratio=0.50 grade=B | *

במערך שלושה תאים, והלולאה קוראת בכל אחד רק את השדה שהתג בוחר: 42 נכנס ל-count כי הוא הראשון ב-union, ואילו ratio ו-grade נבחרו בשמם. בשורה האחרונה דילגנו על התג וקראנו את grade של התא הראשון, כלומר את הבית הנמוך של 42, שהוא התו '*'.

טעויות נפוצות
  • התג מתעדכן אוטומטית בכל כתיבה ל-union. השפה אינה מנהלת תגים אוטומטיים; המתכנת חייב לעדכן את התג בעצמו.
  • המפרט %d על שדה char מדפיס את התו עצמו. %d מדפיס את קוד ה-ASCII המספרי, ורק %c מדפיס את התו.
חזרה לתוכן העניינים

char: בית אחד כמספר וכתו

קודי ASCII ופעולות חשבון על תווים

ההדפסה printf("%c %d", 'H', 'H') מציגה H 72: אותו ערך פעמיים, פעם כתו ופעם כמספר. הסיבה היא ש-char הוא פשוט מספר שלם בן בית אחד (sizeof(char) הוא תמיד 1), וקבוע התו 'H' הוא הקוד שלו בטבלת ASCII. פקודת ההדפסה היא שקובעת מה יוצג: %c מציג תו ו-%d מציג את המספר.

טווח תוויםערכי ASCII
'0' עד '9'48 עד 57
'A' עד 'Z'65 עד 90
'a' עד 'z'97 עד 122
  • הזזה באלפבית: האותיות עוקבות זו לזו, ולכן 'A' + 4 הוא 'E' ו-'Z' - 3 הוא 'W'.
  • מעבר בין רישיות: אות קטנה גבוהה מהגדולה התואמת ב-32 בדיוק, ולכן 'b' - 32 הוא 'B'.
  • מתו ספרה למספר: '7' - '0' הוא 55 - 48, כלומר 7.

בכל חישוב כזה ה-char מקודם ל-int (integer promotion) עוד לפני הפעולה, ולכן גם סכום שמגיע מעל 255 נשמר במלואו. החיתוך לבית אחד קורה רק כשמכניסים את התוצאה בחזרה למשתנה char.

תרחיש 27: מילה באותיות גדולות, מספר מתוך ספרות ותווים בחישוב
C
#include <stdio.h>

int main(void) {
    char word[] = "dog";
    for (int i = 0; i < 3; i++) {
        word[i] -= 32;
    }
    printf("%s\n", word);
    char digits[] = {'2', '9', '5'};
    int num = 0;
    for (int k = 0; k < 3; k++) {
        num = num * 10 + (digits[k] - '0');
    }
    printf("%d\n", num);
    char hi = 'z', lo = 'a';
    printf("%d %c\n", hi - lo, lo + 3);
    char s1 = 100, s2 = 100;
    printf("%d\n", s1 + s2);
    return 0;
}
פלט
DOG
295
25 d
200

הלולאה הראשונה מורידה 32 מכל אות קטנה ומקבלת DOG; השנייה מרכיבה מספר מספרות, כשכל ספרה היא digits[i] - '0', והתוצאה 295. 'z' - 'a' הוא 25, ו-lo + 3 מודפס עם %c בתור 'd'. בסוף 100 + 100 הוא 200, מעבר לטווח של char עם סימן, ובכל זאת הוא לא נחתך כי החישוב נעשה ב-int.

טעויות נפוצות
  • '0' + 1 מודפס עם %c בתור 49. %c מדפיס את התו '1'; המספר 49 יודפס רק עם %d.
  • חיבור של שני משתני char נחתך אוטומטית עד 255. בגלל integer promotion החישוב מתבצע בטיפוס int.
בדקו את עצמכם
נתון char c = 'M'; c += 32;. מה מדפיס printf("%d%c", c, c)?

יודפס 109m: 'M' הוא 77, ועוד 32 נותן 109, הקוד של 'm'.

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

טווחי ערכים וגלישה

נתבונן בקטע unsigned char uc = 248; uc += 12;. הביטוי 248 + 12 מחושב ב-int ונותן 260, אבל תא של unsigned char מחזיק רק 0 עד 255, ולכן בהשמה חזרה מורידים כפולות של 256 עד שהערך נכנס: 260 - 256 = 4. זו שארית בחילוק ב-256 ולא עצירה בתקרה (saturation), ולכן 530 הופך ל-18 ו-1000 ל-232.

char בלי ציון סימן הוא ב-gcc על x86 ו-x86-64 עם סימן, בטווח -128 עד 127; רק ב-ARM Linux הוא בלי סימן, ושם 200 נשאר 200. התוצאה של המרת ערך חורג לטיפוס עם סימן נקבעת במימוש, ו-gcc מגלגל אותה באותה שיטה: 127 + 1 הוא -128, ו-200 הוא 200 - 256 = -56.

תרחיש 28: גלישה בטיפוס עם סימן ובלי סימן
C
#include <stdio.h>

int main(void) {
    unsigned char t = 250;
    for (int i = 0; i < 10; i++) {
        t++;
    }
    unsigned char u = 530;
    int widened = 200;
    char s = (char)widened;
    char m = 127;
    m++;
    printf("%d %d %d %d\n", t, u, s, m);
    return 0;
}
פלט
4 18 -56 -128

t עולה בעשר יחידות מ-250: אחרי חמש הוא 255, בשישית חוזר ל-0, ובסוף נשאר 4 (260 מודולו 256). u הוא 18 (530 - 2 * 256), s הוא -56 (200 - 256), ו-m הוא -128. gcc מקמפל גם את unsigned char u = 530;, אך מוסיף כבר בלי דגלים אזהרת -Woverflow שהערך משתנה מ-530 ל-18; ל-(char)widened ול-m++ אין אזהרה.

טעויות נפוצות
  • unsigned char נחסם בתקרה 255. הוא מתגלגל מודולו 256, ללא רוויה.
  • בגלישה הערך מתאפס ל-0 בלי קשר לשארית. הוא ממשיך מ-0 לפי השארית: 260 הופך ל-4.
  • הצבת 300 ב-unsigned char נותנת -44. unsigned char אינו יכול להחזיק מספר שלילי; התוצאה היא 44.
בדקו את עצמכם
מה ערכם של unsigned char a = 255; a++; ושל unsigned char b = 1000;?

a שווה 0, ו-b שווה 232 (1000 - 3 * 256).

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

sizeof של תו, מחרוזת ומצביע

כדי לחשב נכון sizeof על טקסט, חשוב להבחין בין מערך תווים למצביע: בהגדרה char *ptr = "Net!";, האופרטור sizeof(ptr) מודד את המצביע עצמו (8 בתים בארכיטקטורת 64 סיביות) ולא את אורך המחרוזת. לעומתו, במערך char arr[] = "Net!"; המהדר סופר את כל התווים בתוספת תו הסיום '\0' ומקצה 5 בתים, ואם מצוין גודל מפורש כמו char buf[12] = "xy"; הערך נשאר 12.

הבדל חשוב נוסף בין השניים נוגע לכתיבה לזיכרון: התוכן של arr[] ניתן לשינוי חופשי, אך ניסיון לשנות תווים דרך ptr אסור מפני שהוא מצביע למחרוזת ליטרלית. כל מחרוזת ליטרלית כזו, דוגמת "Net!", תופסת בזיכרון בית אחד יותר ממספר תוויה הגלויים בגלל ה-'\0' שנוסף בסופה.

לבסוף, אל תתבלבלו עם קבוע תו בודד: בניגוד ל-C++ (שם sizeof('Q') הוא 1), בשפת C קבועים כמו 'Q' הם מטיפוס int ולכן sizeof('Q') מחזיר 4.

תרחיש 29: גדלים של מערך, מצביע, קבוע תו וליטרל מחרוזת
C
#include <stdio.h>

int main(void) {
    char buf[12] = "xy";
    char name[] = "Net!";
    char *ptr = name;
    printf("%zu %zu %zu %zu %zu\n", sizeof(buf), sizeof(name), sizeof(ptr), sizeof('Q'), sizeof("AB"));
    return 0;
}
פלט
12 5 8 4 3

buf שומר את הגודל המפורש 12; name הוא ארבעה תווים ועוד '\0', כלומר 5; ptr הוא מצביע, 8 בתים; 'Q' הוא int, כלומר 4; ו-"AB" הוא שני תווים ועוד '\0', כלומר 3.

טעויות נפוצות
  • sizeof("AB") שווה 2. ליטרל מחרוזת כולל את '\0' בסופו, ולכן גודלו 3.
  • sizeof(ptr) מחזיר את אורך המחרוזת שאליה הוא מצביע. הוא מחזיר את גודל המצביע עצמו (8 בתים ב-64 סיביות).
  • sizeof('A') שווה 1. ב-C קבוע תו הוא int, ולכן גודלו 4.
חזרה לתוכן העניינים

long: רוחב התלוי בפלטפורמה

כמה בתים תופס long

ההצהרה long n; אינה קובעת בעצמה כמה בתים יוקצו: התקן מבטיח רק ש-long (או long int, או signed long, שלושתם אותו טיפוס) הוא מספר שלם עם סימן של 32 סיביות לפחות. הרוחב בפועל תלוי במודל הנתונים של המערכת.

סביבהמודל נתוניםintlonglong longמצביע
Linux ו-macOS (64 סיביות)LP644888
Windows (64 סיביות)LLP644488
מערכות 32 סיביותILP324484
תרחיש 30: אותה תוכנית, מודל נתונים אחר
C
#include <stdio.h>
#include <limits.h>

int main(void) {
    printf("%zu %zu %zu %zu\n", sizeof(int), sizeof(long), sizeof(long long), sizeof(void *));
    printf("%ld\n", LONG_MAX);
    return 0;
}
פלט
4 4 8 8
2147483647

התוכנית הורצה עם gcc 16 (MinGW) על Windows 64 סיביות, ולכן long הוא 4 בתים ו-LONG_MAX זהה לערך המרבי של int. בלינוקס x86-64 אותה תוכנית מדפיסה 4 8 8 8 ואת 9223372036854775807; את זה לא הרצנו כאן, כי אין בסביבה מהדר ללינוקס, והערכים הם אלה של מודל LP64 מהטבלה.

בשאלות על gcc בלינוקס x86-64 מניחים אפוא ש-long הוא 8 בתים, והטווח החיובי שלו מגיע עד LONG_MAX = 9223372036854775807 (2^63 - 1), בעוד ש-int נשאר 4 בתים ומקסימומו 2147483647.

כשהתוכנית צריכה להתנהג אותו דבר בכל פלטפורמה לא סומכים על long: int32_t ו-int64_t מ-<stdint.h> מבטיחים רוחב. להדפסה משתמשים ב-%ld ל-long וב-%zu לתוצאת sizeof.

טעויות נפוצות
  • long תופס תמיד 4 בתים או תמיד 8 בתים. הגודל תלוי במודל הנתונים של המערכת (LP64 מול LLP64).
  • במעבד 64 סיביות גם int מתרחב ל-8 בתים. בכל המודלים המודרניים בטבלה int נשאר 4 בתים.
חזרה לתוכן העניינים

קביעת הטיפוס בזמן החישוב

טעות נפוצה במעקב היא להניח שטיפוס המשתנה משמאל ל-= מכתיב את רוחב החישוב שמימין לו. בפועל, רק טיפוסי האופרנדים שבביטוי קובעים: לכן בשורה long x = 100000 * 100000; מתבצע כפל של שני int שגולש עוד לפני שההשמה מתרחשת, ואילו אם לפחות אחד האופרנדים הוא long, השני מקודם אוטומטית ל-long והפעולה מחושבת ברוחב המלא.

כדי להפוך קבוע ליטרלי ל-long, מצמידים לו את הסיומת L (למשל 100000L). ליטרל עשרוני ללא סיומת מקבל את הטיפוס int כל עוד הוא נכנס בטווח שלו, אך במודל LP64 ליטרל שחורג מ-INT_MAX (כמו 3000000000) מקודם אוטומטית ל-long.

כדי להבין גלישה, השוו שני טיפוסים באותו רוחב. ב-unsigned int הכלל מוגדר בתקן: 4294967295u + 2 הוא 1, כי החשבון נעשה מודולו 2 בחזקת מספר הסיביות. ב-int רגיל אין כלל כזה: חריגה מעבר ל-2147483647 היא התנהגות לא מוגדרת (UB), כלומר לא נעצרים בתקרה ואין שום ערך מובטח.

תרחיש 31: חשבון ב-64 סיביות (הדגמה ב-long long, מקביל ל-long ב-Linux x86-64)
C
#include <stdio.h>

int main(void) {
    long long width = 70000, height = 90000;
    long long area = width * height;
    long long total = 2147483647LL + 2147483647LL;
    printf("%zu %lld %lld\n", sizeof(width), area, total);
    return 0;
}
פלט
8 6300000000 4294967294

הדגמה זו הורצה עם long long על Windows 64 סיביות (MinGW gcc 16, שם long הוא 4 בתים), כי long long הוא 8 בתים גם ב-Windows וגם בלינוקס. ב-Linux x86-64 הטיפוס long מתנהג כאן אותו דבר: שתי התוצאות חורגות מ-2147483647 ונכנסות ב-8 בתים בלי גלישה.

תרחיש 32: שני משתני long ושני מקרים של גלישה
C
#include <stdio.h>

int main(void) {
    long a = 2000000000, b = 2000000000;
    long s = a + b;
    printf("%ld\n", s);
    unsigned int u = 4294967295u;
    u = u + 2;
    printf("%u\n", u);
    return 0;
}
פלט
-294967296
1

המכונה כאן היא Windows, ולכן a + b חושב ב-long של 4 בתים; הפלט למעלה הוא מה ש-gcc הפיק בהרצה זו, וההתנהגות בתקן לא מוגדרת. ב-Linux x86-64 שני המשתנים הם 8 בתים, והסכום 4000000000 נכנס בלי גלישה (חישוב ידני, לא הרצה). הגלישה של ה-unsigned int מוגדרת היטב וזהה בכל פלטפורמה.

טעויות נפוצות
  • הצבה למשתנה long גורמת לאגף ימין להתחשב ב-long. המהדר קובע את טיפוס החישוב לפי האופרנדים באגף ימין בלבד.
  • ב-Linux x86-64, הביטוי v + 1 כש-v הוא long שערכו 2147483647 גולש לשלילי. בגלל ש-v הוא long בן 8 בתים, התוצאה היא 2147483648.
  • גלישה של int נתקעת בערך המקסימלי. גלישת שלם עם סימן היא התנהגות לא מוגדרת.
  • אפשר להדפיס long עם %d. מפרט הפורמט של long הוא %ld.
בדקו את עצמכם
ב-Linux x86-64, באיזה טיפוס מחושב 4000000 * 3000 ובאיזה 4000000L * 3000?

הראשון מחושב ב-int וגולש (התנהגות לא מוגדרת), והשני מחושב ב-long ומניב 12000000000.

מהו הערך של sizeof(long) * 3 ב-Linux x86-64?

24.

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

atoi: המרת מחרוזת למספר שלם

שלבי הפענוח של atoi

נעקוב אחרי קריאה אחת, atoi(" -37kg4"), כדי לראות מה atoi (מתוך <stdlib.h>, בחתימה int atoi(const char *s)) עושה בכל חלק של המחרוזת:

חלק במחרוזתמה atoi עושהמה שנצבר
שני רווחיםמדלגת על רווחים לבנים בתחילת המחרוזתכלום
- (או +)סימן אחד, פלוס או מינוס, וספרה חייבת לבוא מיד אחריוסימן שלילי (+ לא משנה את הערך)
3ספרה עשרונית ראשונה3
7ספרה נוספת37
kאינה ספרה, הקריאה נעצרת (g ו-4 לא נקראים)התוצאה היא -37

אם עד נקודת העצירה לא נקראה אף ספרה, התוצאה היא 0, בלי שום הודעת שגיאה, ולכן קריאה על "abc" נראית בדיוק כמו קריאה על "0". לטיפול בכשל או בחריגה מטווח int (שבה התנהגות atoi לא מוגדרת) משתמשים ב-strtol(s, &end, base).

תרחיש 33: בדיקת מקרי קצה של atoi בהרצה
C
#include <stdio.h>
#include <stdlib.h>

int main(void) {
    const char *cases[] = {"2048", "   63", "17.9", "0x2A", "5e3", "007", "- 9", "+-4", "12abc34", ""};
    for (int i = 0; i < 10; i++) {
        printf("[%s] -> %d\n", cases[i], atoi(cases[i]));
    }
    return 0;
}
פלט
[2048] -> 2048
[   63] -> 63
[17.9] -> 17
[0x2A] -> 0
[5e3] -> 5
[007] -> 7
[- 9] -> 0
[+-4] -> 0
[12abc34] -> 12
[] -> 0

בפלט: 17.9 נותנת 17 כי הנקודה אינה ספרה ואין עיגול; 0x2A נותנת 0 כי atoi קוראת עשרוני בלבד ונעצרת כבר ב-x; 5e3 נותנת 5 כי אין כאן סימון מעריכי; 007 נותנת 7; ו-12abc34 נותנת 12, כי הקריאה נעצרת באות הראשונה. המחרוזת "- 9" נותנת 0 כי אחרי הסימן בא רווח ולא ספרה, "+-4" נותנת 0 כי הסימן השני אינו ספרה (מותר סימן אחד, פלוס או מינוס, ואחריו ספרה מיד), והמחרוזת הריקה נותנת 0, כמו 0 עצמה.

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

טעויות נפוצות
  • כשיש אותיות אחרי המספר, atoi מחזירה 0. היא מחזירה את הספרות שקראה עד האות הראשונה.
  • atoi("17.9") מעגלת ל-18. היא נעצרת בנקודה העשרונית ומחזירה 17.
  • atoi מפענחת רק את הספרה הראשונה. היא קוראת את כל רצף הספרות העשרוניות.
  • atoi נכשלת על מחרוזת ליטרלית או בת תו אחד. לדוגמה, atoi("4") מחזירה 4 ללא בעיה.
בדקו את עצמכם
מה מחזירות atoi(" 0042"), atoi("3-2") ו-atoi("+ 6")?

42, 3 ו-0 (ב-"+ 6" יש רווח בין הפלוס לספרה, ולכן הקריאה נעצרת מיד).

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

שילוב argc, argv ו-atoi

הריצו ./sum 30 12x: main מקבלת את שלוש המילים כמערך מחרוזות בשם argv, ואת מספרן ב-argc, שהוא כאן 3. המילה הראשונה, argv[0], היא שם התוכנית עצמה, ולכן הארגומנטים של המשתמש מתחילים ב-argv[1].

כל אחד מהם הוא טקסט ("30" ו-"12x"), גם כשנראה כמו מספר, וכדי לחשב איתו עוברים דרך atoi. לפני כן בודקים ש-argc גדול מספיק: argv[argc] הוא מצביע ריק, ו-atoi שמקבלת אותו מתרסקת, וגישה לאיבר רחוק יותר חורגת מהמערך. החתימה שמקבלת את הנתונים היא int main(int argc, char *argv[]).

תרחיש 34: חיבור של שני ארגומנטים מספריים
C
#include <stdio.h>
#include <stdlib.h>

int main(int argc, char **argv) {
    int enough = argc >= 3;
    if (!enough) {
        printf("need two numbers\n");
        return 1;
    }
    int sum = atoi(argv[1]) + atoi(argv[2]);
    printf("argc=%d sum=%d\n", argc, sum);
    return 0;
}
פלט
argc=3 sum=42

בהרצה עם 30 ו-12x נקראו 30 ו-12 (atoi נעצרת ב-x), הסכום הוא 42 ו-argc הוא 3. בהרצה בלי ארגומנטים argc הוא 1, ולכן enough הוא 0 והתוכנית מדפיסה need two numbers ומסיימת.

טעויות נפוצות
  • argc אינו סופר את שם התוכנית. שם התוכנית תמיד נספר ב-argv[0], כך שעם ארגומנט אחד argc הוא 2.
  • ארגומנט שמכיל אותיות גורם ל-atoi להחזיר 0. אם הוא מתחיל בספרות, atoi מחזירה אותן עד התו הלא-ספרתי.
חזרה לתוכן העניינים

switch: הסתעפות לפי ערך שלם

כיצד switch בוחר תווית

נתבונן ב-switch (n * 2) עם התוויות case 2, case 4 ו-case 6. כש-n הוא 2, הביטוי נותן 4 והביצוע קופץ ישר אל case 4, בלי לעבור דרך case 2 שמעליו. מכאן נגזר העיקר: הביטוי מחושב פעם אחת בלבד, והקפיצה נקבעת לפי שוויון מדויק ולא לפי סדר הכתיבה או קרבה (הערך 5 לא ינחת על 4 או על 6).

מכאן גם ההגבלות: הביטוי אינו יכול להיות float, double, מחרוזת או מצביע, ומותרים טיפוסים שלמים כמו int, char, long ו-enum. התוויות חייבות להיות קבועים שלמים (כמו 3, 'a' או קבוע enum) שונים זה מזה, כדי שלכל ערך יהיה יעד אחד. הביטוי עצמו יכול לכלול חישוב כמו p + 1, וקבועי enum נבחנים לפי ערכם המספרי.

אם אין תווית שווה, הביצוע עובר ל-default; ואם גם הוא חסר, כל גוף ה-switch מדולג.

תרחיש 35: ביטוי מחושב, קבועי enum וגוף בלי default
C
#include <stdio.h>
enum Level { L_MID = 4, L_HIGH };

static int score(int code) {
    switch (code / 10) {
    case 0: return 100;
    case L_MID: return 200;
    case L_HIGH + 1: return 300;
    }
    return -1;
}

int main(void) {
    int codes[] = {7, 45, 66, 52};
    for (int i = 0; i < 4; i++) {
        printf("%d;", score(codes[i]));
    }
    printf("\n");
    return 0;
}
פלט
100;200;300;-1;

עבור 7 הביטוי 7 / 10 נותן 0, והקפיצה היא ל-case 0. עבור 45 מתקבל 4, השווה ל-L_MID, ועבור 66 מתקבל 6, השווה ל-L_HIGH + 1 (כש-L_HIGH הוא 5). עבור 52 מתקבל 5: אין תווית כזו (4 ו-6 קרובות אך לא נבחרות) ואין default, ולכן הגוף מדולג והפונקציה מגיעה ל-return -1.

טעויות נפוצות
  • switch מתחיל תמיד מה-case הראשון בקוד. הביצוע קופץ ישירות לתווית שהערך שלה שווה לביטוי.
  • אם אין התאמה מדויקת, נבחרת התווית הקרובה ביותר. נדרש שוויון מדויק; אחרת רץ default או שלא רץ דבר.
  • הערך 2 קופץ לתווית השנייה מלמעלה. הוא קופץ ל-case 2, ללא תלות במיקומו בטקסט.
  • ענף default מדפיס אוטומטית את המילה default. הוא מריץ רק את הפקודות שכתובות תחתיו.
חזרה לתוכן העניינים

נפילה (fall-through) והוראת break

בתווית case כתוב רק היכן להיכנס, ולא היכן לצאת: אחרי הכניסה הביצוע ממשיך שורה אחר שורה, גם אל פקודות של תוויות שמתחת. התופעה נקראת fall-through (נפילה). עוצרים אותה עם break (שיוצא אל מה שאחרי ה-switch), עם return, או כשהגוף נגמר; בתוך לולאה גם continue עוצר אותה.

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

תרחיש 36: מעקב נפילה בלולאה
C
#include <stdio.h>

int main(void) {
    for (int v = 1; v <= 6; v++) {
        switch (v) {
        case 1: printf("a");
        case 2: printf("b");
        case 3: printf("c"); break;
        case 5: printf("e");
        case 4: printf("d");
        }
        printf(";");
    }
    printf("\n");
    return 0;
}
פלט
abc;bc;c;d;ed;;
vיעד הקפיצהמהלך הביצועפלט בסיבוב
1case 1a, נפילה ל-case 2 (b) ול-case 3 (c), breakabc;
2case 2b, נפילה ל-case 3 (c), breakbc;
3case 3c, breakc;
4case 4d, סוף ה-switchd;
5case 5e, נפילה ל-case 4 שמתחתיו בטקסט (d)ed;
6אין התאמה ואין defaultדילוג על הגוף;

אחרי כל סיבוב מודפס ; מחוץ ל-switch, ולכן סיבוב 6 תורם רק אותו.

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

מיקום default בתוך הגוף

מי שחושב ש-default חייב לבוא אחרון, או שהוא רץ ראשון כשהוא כתוב ראשון, טועה בשני המקרים. default הוא תווית רגילה שאפשר לכתוב בכל נקודה בגוף, והיעד שנבחר אינו תלוי בה: קופצים אליה רק כשאין case מתאים. מה שהמיקום כן משנה הוא הנפילה: מי שמגיע אליה מלמעלה מריץ אותה, ואם היא לא נגמרת ב-break היא ממשיכה אל התוויות שמתחתיה.

תרחיש 37: default בראש ה-switch
C
#include <stdio.h>

static void run(int level) {
    switch (level) {
    default: printf("X");
    case 1: printf("Y"); break;
    case 4: printf("Z");
    case 6: printf("W");
    }
    printf("/");
}

int main(void) {
    run(1);
    run(4);
    run(9);
    run(6);
    printf("\n");
    return 0;
}
פלט
Y/ZW/XY/W/
levelיעד הקפיצהמה רץפלט
1case 1Y, breakY/
4case 4Z, נפילה ל-case 6 (W)ZW/
9אין התאמה, לכן defaultX, נפילה כלפי מטה ל-case 1 (Y), breakXY/
6case 6WW/

default כתוב ראשון, אבל הוא נבחר רק עבור 9, שאין לו תווית; ומשם הוא נופל אל case 1. עבור 4 הוא מדולג לגמרי.

טעויות נפוצות
  • default חייב להופיע בסוף ה-switch. מותר למקם אותו בכל מקום בגוף.
  • default שבראש הבלוק רץ גם כשיש case תואם. קופצים אליו רק כשאין התאמה.
  • כשיש case מתאים, לעולם לא מגיעים ל-default. אפשר להגיע אליו בנפילה מ-case שמעליו.
בדקו את עצמכם
מה מודפס עבור m = 5 ועבור m = 3 בקטע switch (m) { case 5: printf("k"); case 9: printf("m"); break; default: printf("n"); case 2: printf("p"); }?

עבור 5 מודפס km, ועבור 3 מודפס np.

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

switch בתוך לולאה: break לעומת continue

ה-break בתוך switch שבתוך לולאה שייך ל-switch: הוא רק סוגר אותו, והלולאה ממשיכה אל הפקודות שאחריו באותו סיבוב. ה-continue שייך ללולאה: הוא עובר לסיבוב הבא ומדלג על כל מה שנשאר בגוף, כולל מה שכתוב אחרי ה-switch.

תרחיש 38: break, continue ונפילה באותה לולאה
C
#include <stdio.h>

int main(void) {
    int count = 0;
    for (int n = 1; n <= 6; n++) {
        switch (n) {
        case 2:
            continue;
        case 3:
            count += 5;
        case 4:
            count += 1;
            break;
        case 6:
            printf("six@%d,", count);
        default:
            count += 2;
        }
        count++;
        printf("%d;", count);
    }
    printf("\n");
    return 0;
}
פלט
3;10;12;15;six@15,18;
nמה קורהמה מודפס
1אין התאמה: default מוסיף 2, ואז count++ (count הוא 3)3;
2continue מדלג על count++ ועל ההדפסהכלום
3+5, נפילה ל-case 4 (+1), break, ואז count++ (count הוא 10)10;
4+1, break, ואז count++ (count הוא 12)12;
5אין התאמה: default מוסיף 2, ואז count++ (count הוא 15)15;
6case 6 מדפיס את count, נופל ל-default (+2), ואז count++ (count הוא 18)six@15,18;
טעויות נפוצות
  • break בתוך switch מסיים גם את הלולאה העוטפת. הוא יוצא רק מה-switch, והלולאה ממשיכה כרגיל.
  • break מדלג על שאר גוף הלולאה. זו הפעולה של continue, לא של break.
בדקו את עצמכם
מה תדפיס הלולאה for (int k = 1; k <= 5; k++) { switch (k) { case 3: continue; case 4: printf("-"); break; } printf("%d", k); }?

12-45.

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

האופרטור ^ (XOR ביטי)

חישוב ביט אחר ביט ותכונות עיקריות

נתחיל בטעות הנפוצה: ^ אינו חזקה. 10 ^ 7 הוא 13, לא עשר בחזקת שבע. ב-C אין אופרטור חזקה בכלל, ולחזקה קוראים ל-pow מ-<math.h>; ^ הוא XOR ביטי (exclusive OR).

הפעולה נעשית ביט מול ביט: בכל מיקום התוצאה היא 1 כששני הביטים שונים, ו-0 כשהם זהים. אפשר לחשוב עליה כעל | שמוותר על המקרה שבו שניהם 1.

ביט אביט ב&|^
00000
01011
10011
11110
Text
13 = 1101
10 = 1010
-----------
13 & 10 = 1000 = 8
13 | 10 = 1111 = 15
13 ^ 10 = 0111 = 7

מהכלל הזה נגזרות כל התכונות. x ^ x הוא 0 (כל ביט מול עצמו זהה), ו-x ^ 0 הוא x. לכן a ^ b ^ b חוזר ל-a: הפעולה השנייה מבטלת את הראשונה, והסדר אינו משנה כי הפעולה חילופית וקיבוצית.

אותו עיקרון מסביר את היפוך הביט: x ^= (1u << n) הופך את הביט במיקום n ומשאיר את האחרים, ואם מפעילים אותו פעמיים מקבלים את המספר המקורי.

גם החלפה בלי משתנה עזר נשענת על זה. עם a = 13 ו-b = 6: אחרי a ^= b מתקבל a = 11, אחרי b ^= a מתקבל b = 13, ואחרי a ^= b מתקבל a = 6. הטריק נשבר כש-a ו-b הם אותו משתנה: הפעולה הראשונה היא x ^ x, התוצאה 0, ומשם הכול נשאר 0.

^ חוקי רק על מספרים שלמים; על float או על מצביע הוא נכשל בהידור. בגרסאות עדכניות של gcc (13 ומעלה) מופיעה אזהרה כשכותבים 10 ^ 7 שמא הכוונה הייתה לחזקה.

תרחיש 39: חישובי XOR, החלפת ערכים והיפוך ביט
C
#include <stdio.h>

int main(void) {
    printf("xor: %d %d %d %d %d\n", 9 ^ 5, 8 ^ 8, 21 ^ 0, 5 ^ 12, 77 ^ 40 ^ 40);
    int a = 13, b = 6;
    a ^= b;
    b ^= a;
    a ^= b;
    printf("%d %d\n", a, b);
    unsigned int flags = 20;
    flags ^= (1u << 4);
    printf("%u\n", flags);
    return 0;
}
פלט
xor: 12 0 21 9 77
6 13
4

1u << 4 הוא 16 (10000 בבינארי), ו-10100 ^ 10000 נותן 00100, כלומר 4: הביט במיקום 4 כבה.

טעויות נפוצות
  • 5 ^ 3 שווה 125. ^ אינו אופרטור חזקה; בבינארי 101 ^ 011 = 110, כלומר 6.
  • ^ מתנהג כמו |. 5 | 3 הוא 7, ואילו 5 ^ 3 הוא 6.
  • ^ מתנהג כמו &. 5 & 3 הוא 1, ואילו 5 ^ 3 הוא 6.
בדקו את עצמכם
מהו הערך של 12 ^ 7?

11, מפני ש-1100 ^ 0111 = 1011.

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

קדימות אופרטורים: == קודם ל-^

ב-C האופרטורים == ו-!= חזקים מכל האופרטורים הביטיים. הדירוג, מהחזק לחלש: == ו-!=, אחריהם &, אחריו ^, ובסוף |.

התוצאה מפתיעה: x ^ y == 7 נקרא כ-x ^ (y == 7). קודם נבדק y == 7 (ונותן 0 או 1), ורק אחר כך מבוצע XOR עם x. כדי לבדוק אם תוצאת ה-XOR שווה ל-7 כותבים (x ^ y) == 7; עם -Wall, gcc מזהיר על הביטוי בלי סוגריים, אך הוא מתקמפל ורץ.

תרחיש 40: אותו ביטוי עם סוגריים ובלעדיהם
C
#include <stdio.h>

int main(void) {
    int a = 9, b = 3;
    printf("%d %d %d\n", a ^ b == 3, (a ^ b) == 10, a | b == 4);
    return 0;
}
פלט
8 1 9
ביטויפירוש בפועלשלבי חישובתוצאה
a ^ b == 3a ^ (b == 3)9 ^ 18
(a ^ b) == 10כפי שנכתב10 == 101
a | b == 4a | (b == 4)9 | 09
טעויות נפוצות
  • בביטוי x ^ y == 7, ה-XOR מחושב לפני ההשוואה. == קודם ל-^ בסדר הקדימות.
  • ביטוי שמכיל == מחזיר בהכרח 0 או 1. כאן ההשוואה מתבצעת ראשונה ומוזנת לתוך ^, שיכול להחזיר כל מספר שלם.
בדקו את עצמכם
עבור int a = 4, b = 7;, מהם הערכים של a ^ b == 7 ושל (a ^ b) == 3?

5 ו-1: בראשון b == 7 הוא 1 ו-4 ^ 1 שווה 5; בשני 4 ^ 7 הוא 3 ו-3 == 3 שווה 1.

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

סיכום

מעקב מדויק אחרי תוכנית C דורש סדר עבודה קבוע של שלושה שלבים: קודם הרחבת טקסט על ידי המעבד המקדים, אחר כך הרצה שורה-שורה של הקוד המורחב עם מעקב משתנים, ולבסוף בדיקת הפורמט המדויק של printf (מפרטים, רווחים וירידות שורה).

תרחיש 41: תרחיש מסכם: מאקרו, enum, נפילה ב-switch והידור מותנה
C
#include <stdio.h>
#define STEP 4
#define TWICE(x) ((x) + (x))
enum Cmd { C_PUSH = 2, C_POP, C_RESET };

int main(void) {
    int depth = 1;
    for (int c = C_PUSH; c <= C_RESET; c++) {
        switch (c) {
        case C_PUSH: depth += TWICE(STEP);
        case C_POP:  depth -= 3; break;
        default:     depth = depth * 2;
        }
        printf("%d,", depth);
    }
#ifdef STEP
    printf(" step=%d\n", STEP);
#else
    printf(" nostep\n");
#endif
    return 0;
}
פלט
6,3,6, step=4

בשלב ההרחבה TWICE(STEP) הופך ל-((4) + (4)), ו-#ifdef STEP מתקיים כי STEP מוגדר, ולכן נשאר רק ה-printf הראשון. קבועי ה-enum הם C_PUSH = 2, C_POP = 3 ו-C_RESET = 4, ולכן הלולאה רצה שלוש פעמים.

cקפיצהמה רץdepth
2case C_PUSH+= 8, נפילה ל--= 3, break6
3case C_POP-= 3, break3
4אין case מתאים, לכן defaultdepth מוכפל ב-26
נושא בקודנקודות לבדיקה מיידית
מעקב ו-printfהרחבה לפני חישוב, מפרטי %d, %ld, %zu, %c, %s, %X ורווחים.
#define ו-#undefהחלפת טקסט פשוטה לפי הסדר מלמעלה למטה; ההגדרה הפעילה בנקודת השימוש.
#if, #ifdef, #ifndefגם מאקרו ריק או עם 0 נחשב מוגדר; שם לא מוגדר ב-#if שווה 0.
מאקרו עם פרמטריםסוגריים סביב פרמטרים וגוף, ספירת מופעים של ++, נקודת רצף ב-?:, ו-do { } while (0). # מחזיר מחרוזת (רווח יחיד בין מילים), ## מדביק לשם חדש, והארגומנט שליד # או ## לא עובר הרחבה קודם.
typedef ו-inlinetypedef חל על כל המשתנים בהצהרה; inline שומר בדיקת טיפוסים והערכה יחידה.
enumמתחיל מ-0, ממשיך ב-+1 מערך קודם, 4 בתים ב-x86-64, אינו נאכף בטווח.
structסדר אתחול, העתקה עצמאית של מערך מול מצביע משותף, וריפוד לפי יישור.
unionזיכרון משותף, Little Endian ב-x86-64, גודל השדה הגדול מעוגל ליישור המרבי.
charASCII, %c מול %d, מודולו 256 ב-unsigned char, ו-sizeof('A') == 4.
long8 בתים ב-Linux LP64, 4 ב-Windows LLP64; טיפוס החישוב נקבע לפי האופרנדים.
atoiדילוג רווחים, סימן יחיד, עצירה בתו לא-ספרתי, 0 כשאין ספרות, ו-argc כולל שם התוכנית.
switchקפיצה לפי שוויון, fall-through עד break, default בכל מקום, ו-break מול continue בלולאה.
^ (XOR)XOR ביטי ולא חזקה, חילופי, וקדימותו נמוכה מ-==.
בדקו את עצמכם
בתרחיש המסכם, מה היה הפלט אילו STEP הוגדר כ-1?

0,-3,-6, step=1: TWICE(1) הוא 2, לכן בסיבוב הראשון 1 + 2 - 3 = 0, בשני 0 - 3 = -3, ובשלישי default מכפיל ל--6.