שפת 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 בפלט הסופי.
כדי לא ליפול באף אחת משתיהן, לא מערבבים: כל שאלה נפתרת בשלושה מעברים נפרדים, וכל מעבר מסתיים בתוצר כתוב לפני שעוברים לבא אחריו.
- מעבר ראשון, התוצר הוא קוד מורחב: כותבים מחדש את התוכנית כפי שהמהדר יקבל אותה. כל ענף של
#if,#ifdefאו#ifndefשלא נבחר נעלם, וכל שם של מאקרו מוחלף בטקסט שהוא מייצג. עד שהכתיבה הזו מסתיימת לא מחשבים אף ערך. - מעבר שני, התוצר הוא טבלת משתנים: עם הקוד המורחב ביד, מתקדמים פקודה אחר פקודה, ובכל פקודה רושמים בטבלה את הערך החדש של כל משתנה שהשתנה.
- מעבר שלישי, התוצר הוא מה שמופיע במסך: עוברים על מחרוזת הפורמט של
printfמשמאל לימין, משבצים בכל%את הערך הבא בתור, ומעתיקים בקפדנות כל רווח, סימן וירידת שורה שכתובים בה.
תרחיש 1: מעקב תלת-שלבי אחרי לולאה עם מאקרו
#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 - 1 | score בסוף הסיבוב |
|---|---|---|---|
| 1 | 0 | 10 * 2 - 1 | 19 |
| 2 | 1 | 19 * 2 - 1 | 37 |
| 3 | 2 | 37 * 2 - 1 | 73 |
| עצירה | 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 מדפיס את התווים שביניהן ולא אותן.
| מפרט | הטיפוס הנקרא | אופן התצוגה | דוגמת פלט |
|---|---|---|---|
%d | int (או char שקודם ל-int) | עשרוני עם סימן | printf("%d", 'G') מדפיס 71 |
%u | unsigned int | עשרוני ללא סימן | 19 |
%ld | long | עשרוני עם סימן | 7000000000 (ב-Linux x86-64, שבו long הוא 8 בתים) |
%lu | unsigned long | עשרוני ללא סימן | printf("%lu", (unsigned long)sizeof(double)) מדפיס 8 |
%zu | size_t (תוצאת sizeof) | עשרוני ללא סימן | 4 |
%x, %X | שלם | בסיס 16 באותיות קטנות או גדולות, בלי 0x | fe או FE |
%02X, %04X | שלם | בסיס 16 ברוחב קבוע, עם אפסים משמאל | 09 או 0009 |
%03d, %05d | int | עשרוני ברוחב קבוע עם אפסים משמאל, כמו בבסיס 16 | printf("%03d", 7) מדפיס 007 |
%c | שלם | התו בטבלת ASCII שקודו הוא המספר | printf("%c", 72) מדפיס H |
%s | מצביע לתו ראשון במחרוזת | כל התווים עד '\0' ללא מרכאות | pass |
%.1f, %.2f | double | נקודה צפה עם ספרה אחת או שתיים אחרי הנקודה | 4.2 או 2.75 |
תרחיש 2: הצגת ערכים במפרטים שונים בשורת פלט אחת
#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: תרגול משולב של קדימות, הגדלה וביטים
#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 על הקובץ.
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: מאקרו בתוך מאקרו: בלי סוגריים ועם סוגריים
#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 נראות כך:
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 ... חדש.
#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: שורת ההגדרה מול שורת השימוש
#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: שרשרת תנאים ומזהה שאינו מאקרו
#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:
int twice(int n) { return n * 2; }#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 פותחת את הבלוק.
#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 מוציא את הפונקציה פעם אחת בלבד, והקומפילציה מצליחה:
#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 וברירת מחדל
#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.
#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), והקריאה משתבשת:
#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: מאקרו מקונן מול פונקציה מקוננת
#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 * x | SQR_BAD(n + 2) | n + 2 * n + 2 | 14 (במקום 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 * b | PROD_BAD(3 + 2, 5) | 3 + 2 * 5 | 13 (במקום 25) |
PROD_BAD(a, b) a * b | PROD_BAD(5, 3 + 2) | 5 * 3 + 2 | 17 |
SUM_BAD(a, b) a + b | 4 * SUM_BAD(1, 3) | 4 * 1 + 3 | 7 (במקום 16) |
SUM_OK(a, b) ((a) + (b)) | 4 * SUM_OK(1, 3) | 4 * ((1) + (3)) | 16 |
SUM_BAD(a, b) a + b | SUM_BAD(3 * 4, 2) | 3 * 4 + 2 | 14 (כאן אין הבדל) |
תרחיש 9: הדגמת המקרים בתוכנית מקומפלת
#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: ארגומנט ביטוי במאקרו תנאי מוגן
#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: קריאות חוזרות למאקרו שמפחית משתנה
#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: החלפת משתנים והדלקת/כיבוי ביטים דרך מאקרו
#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++ במאקרו מקסימום, ערך מוחלט והופעה יחידה
#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 עולה ל-14 | 13 | p = 14 |
PICK_MAX(r++, s) | 3 > 9 שקר, r עולה ל-4 | (s) מחזיר 9 | 9 | r = 4 |
ABS_NUM(neg++) | -7 < 0 אמת, neg עולה ל--6 | -(neg++) נותן -(-6) = 6, neg עולה ל--5 | 6 | neg = -5 |
MUL10(u++) | מופע יחיד: ((u++) * 10) = 4 * 10 | - | 40 | u = 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: מחרוזת, הדבקת מזהים ומעטפת דו-שלבית
#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!אחרי שלב העיבוד המקדים הקוד נראה כך:
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)
כדי לפצל מאקרו על פני כמה שורות שמים \ בסוף שורה, אך חיבור השורות הזה הוא טקסטואלי בלבד ואינו מאגד פקודות לפקודה אחת. כאן מסתתרות שלוש תקלות קלאסיות:
- כמה פקודות אחרי
ifבלי{}: אחרי ההרחבה מתקבלif (c) a(); b();, ורקa()שייכת ל-if, ואילוb()מתבצעת תמיד. עם-Wallמדפיסgccאזהרה בנוסחmacro expands to multiple statements. - גוף בתוך
{ ... }לפניelse: הקריאה נכתבת עם;בסוף, ולכן אחרי ההרחבה נוצרif (c) { ... } ; else .... הפקודה הריקה;סוגרת את ה-if, וה-elseנשאר בלי בן זוג, ומתקבלת שגיאת קומפילציה. - גוף עם
;בתוך ביטוי: כשמאקרו כזה מופיע כארגומנט שלprintf, ה-;נכנס לתוך הסוגריים של הקריאה, וזה אינו תחביר חוקי, כך שהקומפילציה נכשלת.
גוף של כמה פקודות עוטפים ב-do { body } while (0), בלי ; בסוף ההגדרה. בלולאת do התנאי נבדק רק אחרי הסיבוב הראשון, ולכן הגוף רץ בדיוק פעם אחת. המבנה כולו הוא פקודה אחת ממש, ו-; שהקורא כותב אחריו משלים אותה, כך שהמאקרו נכנס אחרי if ולפני else בלי בעיה.
תרחיש 15: שתי פקודות אחרי if מול עטיפת do { } while (0)
#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 הדפיס אותו; בגרסאות אחרות הניסוח עשוי להיות שונה מעט.
#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.
#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
#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: קביעת ערכים עם דילוגים, שליליים וכפילויות
#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_MED | 0 ועוד 1 | 1 |
P_HIGH | = 7 מציב את המונה ל-7 | 7 |
P_URGENT | 7 ועוד 1 | 8 |
P_CRIT | = 12 מציב מחדש | 12 |
DEBT | הצבה של מספר שלילי | -4 |
FEE | -4 ועוד 1 | -3 |
LOW_B | הצבה שלילית נוספת | -1 |
BONUS | הצבה מפורשת | 3 |
EXTRA | הצבה של אותו ערך: שני שמות על מספר אחד | 3 |
TOP_B | 3 ועוד 1 | 4 |
בטבלה רואים גם שהמונה אינו מוגבל למספרים חיוביים: ב-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: ערך מחוץ לרשימה, קבועים בשימושים שלמים וגודל
#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
threepick הוא מספר שלם רגיל, ולכן הוא מחזיק 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 מאגד אותם לטיפוס אחד, והשדות יכולים להיות מכל טיפוס:
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: שלוש צורות אתחול, מצביע ושדה שהושמט
#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: העתקה דרך פרמטר ודרך השמה
#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) | גודל בבתים | יישור נדרש |
|---|---|---|
char | 1 | 1 |
short | 2 | 2 |
int, float, enum | 4 | 4 |
long, double, מצביע | 8 | 8 |
מערך של N איברים מסוג T | N * sizeof(T) | היישור של T |
struct או union | לפי כללי הריפוד | היישור הגדול ביותר מבין שדותיו |
המהדר ממקם את השדות לפי סדר הופעתם בהגדרה, כאשר השדה הראשון תמיד נמצא בהיסט 0. כך תחשבו את הפריסה שדה אחר שדה:
- מתחילים בהיסט
0. - לפני כל שדה מעגלים את ההיסט כלפי מעלה לכפולה הקרובה של היישור שלו; הבתים הריקים שדילגתם עליהם נקראים ריפוד (padding).
- מוסיפים את גודל השדה להיסט הנוכחי.
- בסיום מעגלים את הגודל הכולל כלפי מעלה לכפולה של היישור הגדול ביותר במבנה, כדי שגם במערך של מבנים כל איבר יתחיל בכתובת מיושרת.
תרחיש 22: שישה מבנים פשוטים, מבנים מקוננים ומבנה ארוז
#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| מבנה | פריסה (היסט: שדה) | גודל סופי |
|---|---|---|
M1 | 0..1: a, 2: b, ריפוד סופי 3 | 4 |
M2 | 0: a, ריפוד 1, 2..3: b, 4..7: c | 8 |
M3 | 0: a, ריפוד 1..7, 8..15: d, 16: e, ריפוד סופי 17..23 | 24 |
M4 | 0..7: d, 8: a, 9: e, ריפוד סופי 10..15 | 16 |
M5 | 0..4: name, ריפוד 5, 6..7: s | 8 |
M6 | 0..11: arr, 12: c, ריפוד סופי 13..15 | 16 |
Frame | 0..3: id, 4..6: in, ריפוד 7, 8..9: s, ריפוד סופי 10..11 | 12 |
Shell | 0: tag, ריפוד 1..7, 8..23: w | 24 |
Compact (packed) | 0: k, 1..4: n, 5..6: w | 7 |
הפלט התקבל מ-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
נתחיל מדוגמה: 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: מדידת גודל של חמישה איחודים
#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| איחוד | שדה גדול ביותר | יישור מרבי | תוצאה אחרי עיגול |
|---|---|---|---|
V1 | 9 (tag) | 2 (short) | 9 עולה ל-10 |
V2 | 8 (a) | 4 (int) | 8 נשאר 8 |
V3 | 8 (big) | 8 (long long) | 8 נשאר 8 |
V4 | 17 (buf) | 8 (double) | 17 עולה ל-24 |
V5 | 2 (a) | 2 | 2 נשאר 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 |
|---|---|---|---|---|
בית של 0x1A2B3C4D | 4D | 3C | 2B | 1A |
כדי לדעת מה שדה רואה, התחילו מהכתובת הנמוכה וספרו את הבתים שהשדה מכסה. מערך של ארבעה בתים רואה לפי הסדר 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
#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: מערך של תאים עם תג
#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: מילה באותיות גדולות, מספר מתוך ספרות ותווים בחישוב
#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: גלישה בטיפוס עם סימן ובלי סימן
#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 -128t עולה בעשר יחידות מ-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: גדלים של מערך, מצביע, קבוע תו וליטרל מחרוזת
#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 3buf שומר את הגודל המפורש 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 סיביות לפחות. הרוחב בפועל תלוי במודל הנתונים של המערכת.
| סביבה | מודל נתונים | int | long | long long | מצביע |
|---|---|---|---|---|---|
| Linux ו-macOS (64 סיביות) | LP64 | 4 | 8 | 8 | 8 |
| Windows (64 סיביות) | LLP64 | 4 | 4 | 8 | 8 |
| מערכות 32 סיביות | ILP32 | 4 | 4 | 8 | 4 |
תרחיש 30: אותה תוכנית, מודל נתונים אחר
#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)
#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 ושני מקרים של גלישה
#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 בהרצה
#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: חיבור של שני ארגומנטים מספריים
#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
#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: מעקב נפילה בלולאה
#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 | יעד הקפיצה | מהלך הביצוע | פלט בסיבוב |
|---|---|---|---|
1 | case 1 | a, נפילה ל-case 2 (b) ול-case 3 (c), break | abc; |
2 | case 2 | b, נפילה ל-case 3 (c), break | bc; |
3 | case 3 | c, break | c; |
4 | case 4 | d, סוף ה-switch | d; |
5 | case 5 | e, נפילה ל-case 4 שמתחתיו בטקסט (d) | ed; |
6 | אין התאמה ואין default | דילוג על הגוף | ; |
אחרי כל סיבוב מודפס ; מחוץ ל-switch, ולכן סיבוב 6 תורם רק אותו.
טעויות נפוצות
- רק הקוד של ה-
caseשנבחר מתבצע. ללאbreak, הביצוע ממשיך ונופל לתוויות שאחריו. - נפילה ממשיכה מעבר ל-
break.breakמסיים את ה-switchמיד. - תווית ריקה אינה נחשבת להתאמה. היא מתאימה לערך, והריצה נופלת משם לפקודות הבאות.
מיקום default בתוך הגוף
מי שחושב ש-default חייב לבוא אחרון, או שהוא רץ ראשון כשהוא כתוב ראשון, טועה בשני המקרים. default הוא תווית רגילה שאפשר לכתוב בכל נקודה בגוף, והיעד שנבחר אינו תלוי בה: קופצים אליה רק כשאין case מתאים. מה שהמיקום כן משנה הוא הנפילה: מי שמגיע אליה מלמעלה מריץ אותה, ואם היא לא נגמרת ב-break היא ממשיכה אל התוויות שמתחתיה.
תרחיש 37: default בראש ה-switch
#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 | יעד הקפיצה | מה רץ | פלט |
|---|---|---|---|
1 | case 1 | Y, break | Y/ |
4 | case 4 | Z, נפילה ל-case 6 (W) | ZW/ |
9 | אין התאמה, לכן default | X, נפילה כלפי מטה ל-case 1 (Y), break | XY/ |
6 | case 6 | W | W/ |
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 ונפילה באותה לולאה
#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; |
2 | continue מדלג על 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; |
6 | case 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.
| ביט א | ביט ב | & | | | ^ |
|---|---|---|---|---|
0 | 0 | 0 | 0 | 0 |
0 | 1 | 0 | 1 | 1 |
1 | 0 | 0 | 1 | 1 |
1 | 1 | 1 | 1 | 0 |
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, החלפת ערכים והיפוך ביט
#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
41u << 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: אותו ביטוי עם סוגריים ובלעדיהם
#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 == 3 | a ^ (b == 3) | 9 ^ 1 | 8 |
(a ^ b) == 10 | כפי שנכתב | 10 == 10 | 1 |
a | b == 4 | a | (b == 4) | 9 | 0 | 9 |
טעויות נפוצות
- בביטוי
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 והידור מותנה
#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 |
|---|---|---|---|
2 | case C_PUSH | += 8, נפילה ל--= 3, break | 6 |
3 | case C_POP | -= 3, break | 3 |
4 | אין case מתאים, לכן default | depth מוכפל ב-2 | 6 |
| נושא בקוד | נקודות לבדיקה מיידית |
|---|---|
מעקב ו-printf | הרחבה לפני חישוב, מפרטי %d, %ld, %zu, %c, %s, %X ורווחים. |
#define ו-#undef | החלפת טקסט פשוטה לפי הסדר מלמעלה למטה; ההגדרה הפעילה בנקודת השימוש. |
#if, #ifdef, #ifndef | גם מאקרו ריק או עם 0 נחשב מוגדר; שם לא מוגדר ב-#if שווה 0. |
| מאקרו עם פרמטרים | סוגריים סביב פרמטרים וגוף, ספירת מופעים של ++, נקודת רצף ב-?:, ו-do { } while (0). # מחזיר מחרוזת (רווח יחיד בין מילים), ## מדביק לשם חדש, והארגומנט שליד # או ## לא עובר הרחבה קודם. |
typedef ו-inline | typedef חל על כל המשתנים בהצהרה; inline שומר בדיקת טיפוסים והערכה יחידה. |
enum | מתחיל מ-0, ממשיך ב-+1 מערך קודם, 4 בתים ב-x86-64, אינו נאכף בטווח. |
struct | סדר אתחול, העתקה עצמאית של מערך מול מצביע משותף, וריפוד לפי יישור. |
union | זיכרון משותף, Little Endian ב-x86-64, גודל השדה הגדול מעוגל ליישור המרבי. |
char | ASCII, %c מול %d, מודולו 256 ב-unsigned char, ו-sizeof('A') == 4. |
long | 8 בתים ב-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.