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

שפת C לגאמא סייבר: לקרוא קוד ולדעת מה יודפס

שפת C מופיעה במיוני גאמא סייבר בשתי נקודות. בשאלון המקוון (שאלון גאמא סייבר) שפות תכנות הן אחד מתחומי המושגים שמסמנים, וביום המבחנים, C היא אחד המקצועות ברשימת מבחני הידע, לצד Assembly, Java, Python ואחרים. כל מבחן ידע ברשימה עוסק בנושא אחד, ואף מועמד לא נדרש לכולם.

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

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

מה ידוע על C במיונים, ומה לא

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

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

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

מצביעים ומערכים: אותו סימון, זיכרון אחר

מצביע הוא משתנה שמחזיק כתובת בזיכרון. הכוכבית בהצהרה int *p אומרת ש-p מחזיק כתובת של int, והכוכבית בביטוי *p אומרת 'לכו לכתובת וקראו את הערך שם'.

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

חשבון מצביעים נמדד ביחידות של הטיפוס ולא בבתים: אם p מצביע ל-int, הביטוי p + 1 מתקדם בגודל של int אחד. הסימון p[i] מוגדר בתקן כ-*(p + i), ולכן הוא עובד באותה צורה על מצביע ועל מערך.

קריאת קוד: אחרי int data[5] = {7, 14, 21, 28, 35}; ו-int *p = data + 1; (בהנחה ש-int תופס 4 בתים ומצביע תופס 8)
ביטויערךלמה
*p14p מצביע לאיבר שבאינדקס 1
p[2]28זה *(p + 2), כלומר האיבר שבאינדקס 3 של data
*(data + 4)35שם המערך הפך לכתובת, והחשבון התקדם ארבעה איברים
p - data1הפרש בין מצביעים נמדד באיברים, לא בבתים
sizeof data20גודל המערך כולו: חמישה איברים של 4 בתים
sizeof p8גודל המצביע עצמו, בלי קשר למה שהוא מצביע עליו
מלכודת הצהרה: בשורה int *p, q; רק p הוא מצביע, ו-q הוא int רגיל. הכוכבית נצמדת לשם ולא לטיפוס, ולכן ברור יותר להצהיר על כל מצביע בשורה משלו.

1. מערכים ומצביעים

מה יודפס? הניחו מערכת של 64 ביט שבה int תופס 4 בתים ומצביע תופס 8 בתים.

#include <stdio.h>

static size_t count(int a[]) {
    return sizeof(a) / sizeof(a[0]);
}

int main(void) {
    int nums[6] = {4, 8, 15, 16, 23, 42};
    printf("%zu %zu\n", sizeof(nums) / sizeof(nums[0]), count(nums));
    return 0;
}

בחרו תשובה כדי לראות את ההסבר

מחרוזות ב-C: התו שסוגר כל מחרוזת

ב-C אין טיפוס מחרוזת. מחרוזת היא רצף של char שמסתיים בתו שערכו אפס ('\0'), וכל פונקציה כמו strlen, strcpy או printf עם %s רצה קדימה עד שהיא פוגשת אותו. אם התו הזה חסר, הפונקציה ממשיכה לקרוא זיכרון שלא שייך למחרוזת.

ההבדל בין sizeof ל-strlen חוזר שוב ושוב בקריאת קוד. sizeof הוא גודל האחסון, שידוע כבר בזמן הקומפילציה וכולל את התו הסוגר. strlen סופר תווים בזמן ריצה עד התו הסוגר, ואותו עצמו הוא לא סופר.

קריאת קוד: ארבע הצהרות שנראות כמעט אותו דבר
הצהרהמה מתקבלהערה
char s[] = "abc";מערך של 4 תווים: sizeof s הוא 4 ו-strlen(s) הוא 3הקומפיילר מוסיף את התו הסוגר בעצמו
char *t = "abc";מצביע לליטרל: sizeof t הוא גודל של מצביעשינוי כמו t[0] = 'A' הוא התנהגות לא מוגדרת
char u[3] = "abc";שלושה תווים בלי תו סוגרחוקי ב-C, אבל strlen(u) יקרא מעבר לסוף המערך
char v[8] = "abc";sizeof v הוא 8 ו-strlen(v) הוא 3המקומות שנשארו מתמלאים באפסים

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

2. מחרוזות

מה יודפס?

#include <stdio.h>
#include <string.h>

int main(void) {
    char word[] = "network";
    word[3] = '\0';
    printf("%zu %zu %s\n", sizeof word, strlen(word), word);
    return 0;
}

בחרו תשובה כדי לראות את ההסבר

מחסנית וערימה: מי מחזיק את הזיכרון ועד מתי

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

זיכרון שמבקשים ב-malloc, calloc או realloc מגיע מהערימה (heap), והוא חי עד שקוראים ל-free, בלי קשר לפונקציה שביקשה אותו. הפרטים הקטנים חשובים: malloc לא מאפסת את הזיכרון ו-calloc כן, free(NULL) בטוחה, ושחרור כפול או שימוש אחרי free הם התנהגות לא מוגדרת.

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

קריאת קוד: שתי פונקציות כמעט זהות, וכל אחת נקראת שלוש פעמים ברצף
פונקציההערך בקריאה השלישיתלמה
int f(void) { int n = 0; n += 5; return n; }5n נוצר מחדש בכל קריאה ומתחיל מאפס
int g(void) { static int n = 0; n += 5; return n; }15n מקבל 0 רק לפני הקריאה הראשונה, וכל קריאה ממשיכה מהערך שהשאירה הקודמת

3. מחסנית וערימה

שלוש הפונקציות מחזירות מצביע למחרוזת. איזו או אילו מהן מחזירות מצביע ש-main רשאית לקרוא דרכו, ושאותו עליה לשחרר בעצמה בסוף?

#include <stdlib.h>
#include <string.h>

char *make_a(void) {
    char buf[16];
    strcpy(buf, "ok");
    return buf;
}

char *make_b(void) {
    char *buf = malloc(16);
    if (buf) strcpy(buf, "ok");
    return buf;
}

char *make_c(void) {
    char *buf = malloc(16);
    if (buf) { strcpy(buf, "ok"); free(buf); }
    return buf;
}

בחרו תשובה כדי לראות את ההסבר

פעולות על ביטים: מסכות, הזזות ומלכודת הקדימות

האופרטורים & (וגם), | (או), ^ (או מוציא), ~ (היפוך), << ו->> (הזזה) פועלים על כל ביט בנפרד. אל תבלבלו אותם עם && ו-||, שהם אופרטורים לוגיים שמחזירים 0 או 1 ומפסיקים לחשב ברגע שהתוצאה ידועה, וגם לא עם !, שהופך כל ערך שאינו אפס ל-0 ואת 0 עצמו ל-1.

שלושה דפוסים חוזרים כמעט בכל קוד שמטפל בדגלים: (x >> n) & 1 קורא את ביט n, x | (1u << n) מדליק אותו, ו-x & ~(1u << n) מכבה אותו. עבדו עם טיפוסים unsigned. הזזה ימינה של מספר שלילי תלויה במימוש, והזזה שמאלה של מספר שלילי, גלישה של int עם סימן והזזה במספר ביטים שגדול או שווה לרוחב הטיפוס הן התנהגות לא מוגדרת.

קריאת קוד: x הוא unsigned שערכו 0x5A, כלומר 01011010 בבסיס 2
ביטויתוצאהמה קרה
x & 0x0F0x0Aהמסכה השאירה רק את ארבעת הביטים הנמוכים
x | 0x800xDAהביט העליון של הבית נדלק
x ^ 0xFF0xA5כל שמונת הביטים הנמוכים התהפכו
x >> 40x05ארבעת הביטים העליונים ירדו למטה
(x >> 3) & 11ביט 3 דולק
x & (x - 1)0x58הביט הדולק הנמוך ביותר כבה

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

קריאה מהירה של בסיס 16: כל ספרה הקסדצימלית מייצגת בדיוק ארבעה ביטים, ולכן מתרגמים ספרה אחרי ספרה. 0x9C הוא 9 (1001) ואחריו C (1100), כלומר 10011100, ובעשרוני 156. כך קוראים מסכה בלי לעבור דרך חשבון עשרוני.

4. פעולות על ביטים

מה יודפס? הניחו ש-unsigned int הוא ברוחב 32 ביט.

#include <stdio.h>

int main(void) {
    unsigned int reg = 0xB6;
    unsigned int mid = (reg >> 2) & 0x7;
    reg |= 1u << 8;
    printf("%u %X\n", mid, reg);
    return 0;
}

בחרו תשובה כדי לראות את ההסבר

5. קדימות אופרטורים

מה יודפס?

#include <stdio.h>

int main(void) {
    int flags = 10;
    int first = flags & 1 == 0;
    int second = (flags & 1) == 0;
    int third = flags & 3 << 1;
    printf("%d,%d,%d\n", first, second, third);
    return 0;
}

בחרו תשובה כדי לראות את ההסבר

סדר בתים: מה יושב בכתובת הנמוכה

מספר של 32 ביט תופס ארבעה בתים, והשאלה היא באיזה סדר הם נשמרים בזיכרון. בשיטת little-endian הכתובת הנמוכה מקבלת את הבית שתורם הכי מעט לערך המספר, ובשיטת big-endian היא מקבלת דווקא את הבית שתורם הכי הרבה. מעבדי x86 עובדים ב-little-endian, וברשת מקובל big-endian, שמכונה גם סדר הבתים של הרשת, ולכן קוד רשת ב-C מעביר ערכים דרך htons ו-htonl לפני שליחה.

הערך 0x12345678 בזיכרון, לפי ההיסט מהכתובת שבה הוא מתחיל
היסטlittle-endian (למשל x86)big-endian (סדר הרשת)
07812
15634
23456
31278

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

6. סדר בתים

מה יודפס על מעבד little-endian כמו x86?

#include <stdio.h>
#include <stdint.h>

int main(void) {
    uint32_t value = 0x0A0B0C0D;
    unsigned char *b = (unsigned char *)&value;
    printf("%02X %02X\n", b[0], b[1]);
    return 0;
}

בחרו תשובה כדי לראות את ההסבר

טבלת באגים נפוצים ב-C

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

באגים נפוצים, איך הם נראים ואיך מתקנים
הבאגאיך הוא נראהמה קורההתיקון
אין מקום לתו הסוגרchar name[5]; strcpy(name, "hello");שישה בתים נכתבים למערך של חמישה, וזו גלישת חוצץלהקצות strlen + 1 בתים, או להשתמש בפונקציה שמקבלת את גודל היעד
sizeof על פרמטרsizeof(arr) בתוך פונקציה שקיבלה מערךמתקבל גודל של מצביע ולא של המערךלהעביר את האורך כפרמטר נפרד
פונקציה שמחזירה מצביע למערך שלהreturn buf; כש-buf הוא מערך מקומיהמצביע מפנה למקום במחסנית שכבר לא שייך לפונקציהלהקצות ב-malloc, או לקבל חוצץ מהפונקציה שקוראת
שימוש אחרי freefree(p); ואחר כך p[0] = 1;התנהגות לא מוגדרת, לפעמים בלי שום סימןלא לגעת בבלוק אחרי free. הצבת p = NULL היא רק אמצעי זהירות שעוזר לתפוס את הטעות, ולא מגינה על עותקים אחרים של המצביע
דליפת זיכרוןmalloc בתוך לולאה בלי free מתאיםהזיכרון של התהליך גדל עד שהוא נגמרלקבוע לכל malloc מי משחרר ומתי
השמה במקום השוואהif (x = 0)x מקבל 0 והתנאי תמיד שקרילכתוב == ולקמפל עם -Wall
קדימות של &if (x & 1 == 0)מתפרש כ-x & (1 == 0), ולכן תמיד 0סוגריים: (x & 1) == 0
כוכבית אחת לשני משתניםint *p, q;רק p הוא מצביעהצהרה נפרדת לכל מצביע
הנחה ש-malloc מאפסתקריאה מזיכרון שהוקצה לפני שנכתב בו משהוערכים שאריים ולא צפוייםcalloc, או אתחול מפורש
שינוי של ליטרלchar *s = "abc"; s[0] = 'A';התנהגות לא מוגדרת, ולרוב קריסהchar s[] = "abc"; כשצריך לשנות את התוכן
שני שינויים בלי סדר מוגדרi = i++ + 1;התנהגות לא מוגדרת, ואין תשובה נכונה אחתלפצל לשתי פקודות
פורמט לא תואם ב-printf%d עבור long או עבור מצביעהתנהגות לא מוגדרת%ld ל-long, %zu ל-size_t, %p עם המרה ל-void * למצביע
גלישה של int עם סימןINT_MAX + 1התנהגות לא מוגדרת, לא עטיפה למספר שליליunsigned כשצריך עטיפה, או בדיקה לפני החישוב

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

סדר עבודה לתרגול C

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

  1. לנבא לפני שמריצים. על כל קטע קוד כותבים על דף מה יודפס, ורק אחר כך מקמפלים ומשווים. השלב הושלם כשאתם צודקים ברוב הקטעים בלי להריץ.
  2. לקמפל עם אזהרות. מריצים gcc -Wall -Wextra וקוראים כל אזהרה עד הסוף. בגרסה עדכנית של gcc, שלוש מתוך שש השאלות במאמר מקבלות אזהרה שמצביעה בדיוק על המלכודת. השלב הושלם כשאתם יודעים להסביר כל אזהרה שקיבלתם.
  3. לתת לכלי לתפוס באגים של זיכרון. בקוד עם מצביעים וזיכרון דינמי מוסיפים -fsanitize=address, שזמין ב-gcc וב-clang ברוב התקנות Linux. הוא עוצר על קריאה מחוץ למערך ועל שימוש אחרי free. השלב הושלם כשתרגילי הזיכרון שלכם עוברים בלי הודעות שגיאה מהכלי.
  4. לכתוב לבד שלוש פונקציות קטנות. strlen משלכם, העתקת מחרוזת שמקבלת את גודל היעד, ופונקציה שסופרת ביטים דולקים במספר unsigned. השלב הושלם כשכל אחת עובדת גם על קלט ריק וגם על קלט בגודל המקסימלי.
  5. לפתוח כל שאלה בהנחות. בשאלות על גדלים או על סדר בתים כותבים קודם כמה בתים יש ב-int, כמה במצביע ובאיזה סדר הבתים נשמרים. השלב הושלם כשזה הדבר הראשון שאתם עושים בלי לחשוב.
  6. לסמן בשאלון רק מה שהסברתם. מושג כמו 'מצביע' או 'ערימה' מסמנים רק אם תוכלו להסביר אותו בעל פה, למשל מה ההבדל בין מערך למצביע. ההיגיון מאחורי הכלל מוסבר בעמוד על השאלון.

להמשיך לתרגל

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

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

שאלות נפוצות

האם חייבים לדעת C כדי להתקבל לגאמא סייבר?

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

על איזה קומפיילר ואיזה תקן של C השאלות מתבססות?

זה לא פורסם. לכן כל שאלה במאמר מציינת את ההנחות שלה (גודל int, גודל מצביע, סדר בתים), כל קטעי הקוד קומפלו ב-gcc בתקן C99, ואלה שיש בהם main גם הורצו כדי לוודא שהם מדפיסים את מה שהתשובה אומרת.

האם בסדנה המעשית כותבים ב-C?

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

מה כדאי ללמוד קודם: מצביעים או פעולות על ביטים?

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

האם השאלות כאן משקפות את רמת הקושי ביום המבחנים?

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

להמשך קריאה

עודכן לאחרונה: 2026-11-12