שפת 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), ולכן הוא עובד באותה צורה על מצביע ועל מערך.
| ביטוי | ערך | למה |
|---|---|---|
| *p | 14 | p מצביע לאיבר שבאינדקס 1 |
| p[2] | 28 | זה *(p + 2), כלומר האיבר שבאינדקס 3 של data |
| *(data + 4) | 35 | שם המערך הפך לכתובת, והחשבון התקדם ארבעה איברים |
| p - data | 1 | הפרש בין מצביעים נמדד באיברים, לא בבתים |
| sizeof data | 20 | גודל המערך כולו: חמישה איברים של 4 בתים |
| sizeof p | 8 | גודל המצביע עצמו, בלי קשר למה שהוא מצביע עליו |
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;
}בחרו תשובה כדי לראות את ההסבר
הסבר: בתוך main, sizeof(nums) הוא 24 בתים ו-sizeof(nums[0]) הוא 4, ולכן החלוקה נותנת 6. בתוך count הפרמטר int a[] הוא בעצם int *, ולכן sizeof(a) הוא 8 והתוצאה היא 2. מי שבוחר 6 6 מניח שהמערך עובר לפונקציה יחד עם הגודל שלו, ו-6 1 מתאים למצביע של 4 בתים, לא להנחה שבשאלה.
מחרוזות ב-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;
}בחרו תשובה כדי לראות את ההסבר
הסבר: המערך word מקבל 8 מקומות, שבע אותיות ועוד התו הסוגר, ו-sizeof מחזיר את הגודל הזה גם אחרי השינוי. ההשמה word[3] = '\0' מציבה תו סוגר מיד אחרי net, ולכן גם strlen וגם %s עוצרים שם. מי שעונה 7 3 net שוכח שהתו הסוגר נספר ב-sizeof, ומי שעונה 8 3 network מניח ש-%s מדפיס את כל המערך.
מחסנית וערימה: מי מחזיק את הזיכרון ועד מתי
משתנה מקומי רגיל נוצר כשהפונקציה נקראת ונעלם כשהיא חוזרת. במימושים הנפוצים הוא יושב על מחסנית הקריאות, שגדלה עם כל קריאה ומתקצרת עם כל חזרה. התקן של C לא מזכיר מחסנית בכלל, ולכן גם הכיוון שבו היא גדלה הוא פרט של המעבד (ב-x86 היא גדלה לכיוון הכתובות הנמוכות) ולא חוק של השפה.
זיכרון שמבקשים ב-malloc, calloc או realloc מגיע מהערימה (heap), והוא חי עד שקוראים ל-free, בלי קשר לפונקציה שביקשה אותו. הפרטים הקטנים חשובים: malloc לא מאפסת את הזיכרון ו-calloc כן, free(NULL) בטוחה, ושחרור כפול או שימוש אחרי free הם התנהגות לא מוגדרת.
יש גם סוג שלישי שמבלבל רבים: משתנה מקומי שהוגדר עם static. הוא נראה מקומי, אבל הוא נוצר פעם אחת לכל אורך התוכנית וזוכר את ערכו בין קריאה לקריאה.
| פונקציה | הערך בקריאה השלישית | למה |
|---|---|---|
| int f(void) { int n = 0; n += 5; return n; } | 5 | n נוצר מחדש בכל קריאה ומתחיל מאפס |
| int g(void) { static int n = 0; n += 5; return n; } | 15 | n מקבל 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;
}בחרו תשובה כדי לראות את ההסבר
הסבר: make_a מחזירה כתובת של מערך מקומי, שהזיכרון שלו כבר לא שייך לאף אחד אחרי החזרה, ולכן קריאה דרכו היא התנהגות לא מוגדרת (gcc אף מזהיר על כך). make_c משחררת את הבלוק לפני שהיא מחזירה אותו, כך שהמצביע שמוחזר תלוי באוויר. רק make_b מחזירה זיכרון מהערימה שעדיין חי, והאחריות לקרוא ל-free עוברת למי שקרא לה. התשובה 'make_b ו-make_c' מפתה כי גם ב-make_c ההקצאה הצליחה, אבל free כבר החזירה את הבלוק.
פעולות על ביטים: מסכות, הזזות ומלכודת הקדימות
האופרטורים & (וגם), | (או), ^ (או מוציא), ~ (היפוך), << ו->> (הזזה) פועלים על כל ביט בנפרד. אל תבלבלו אותם עם && ו-||, שהם אופרטורים לוגיים שמחזירים 0 או 1 ומפסיקים לחשב ברגע שהתוצאה ידועה, וגם לא עם !, שהופך כל ערך שאינו אפס ל-0 ואת 0 עצמו ל-1.
שלושה דפוסים חוזרים כמעט בכל קוד שמטפל בדגלים: (x >> n) & 1 קורא את ביט n, x | (1u << n) מדליק אותו, ו-x & ~(1u << n) מכבה אותו. עבדו עם טיפוסים unsigned. הזזה ימינה של מספר שלילי תלויה במימוש, והזזה שמאלה של מספר שלילי, גלישה של int עם סימן והזזה במספר ביטים שגדול או שווה לרוחב הטיפוס הן התנהגות לא מוגדרת.
| ביטוי | תוצאה | מה קרה |
|---|---|---|
| x & 0x0F | 0x0A | המסכה השאירה רק את ארבעת הביטים הנמוכים |
| x | 0x80 | 0xDA | הביט העליון של הבית נדלק |
| x ^ 0xFF | 0xA5 | כל שמונת הביטים הנמוכים התהפכו |
| x >> 4 | 0x05 | ארבעת הביטים העליונים ירדו למטה |
| (x >> 3) & 1 | 1 | ביט 3 דולק |
| x & (x - 1) | 0x58 | הביט הדולק הנמוך ביותר כבה |
כדאי לזכור את השורה האחרונה בטבלה: מספר חיובי הוא חזקה של 2 בדיוק כאשר x & (x - 1) יוצא 0. ועוד שתי זהויות שחוסכות זמן בקריאה: x ^ x הוא תמיד 0, ו-x ^ 0 הוא x עצמו.
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;
}בחרו תשובה כדי לראות את ההסבר
הסבר: 0xB6 הוא 10110110. הזזה ימינה בשני ביטים נותנת 00101101, והמסכה 0x7 משאירה את שלושת הביטים הנמוכים 101, כלומר 5. אחר כך 1u << 8 הוא 0x100, וה-| מוסיף ביט תשיעי, והתוצאה היא 0x1B6. התשובה 5 B6 מניחה שביט 8 נופל מחוץ לבית, אבל reg הוא unsigned int ולא בית בודד, ו-45 מתקבל אם שוכחים את המסכה.
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;
}בחרו תשובה כדי לראות את ההסבר
הסבר: ל-== יש קדימות גבוהה יותר מאשר ל-&, ולכן flags & 1 == 0 מתפרש כ-flags & (1 == 0), כלומר 10 & 0, שהוא 0. בשורה של second הסוגריים מתקנים את הסדר: 10 & 1 הוא 0, ו-0 == 0 הוא 1. גם להזזה יש קדימות גבוהה מ-&, ולכן third הוא 10 & (3 << 1), כלומר 10 & 6, שהוא 2. מי שבוחר 0,1,4 חישב בטעות (10 & 3) << 1, ומי שבוחר 1,1,2 הניח ש-first ו-second זהים.
סדר בתים: מה יושב בכתובת הנמוכה
מספר של 32 ביט תופס ארבעה בתים, והשאלה היא באיזה סדר הם נשמרים בזיכרון. בשיטת little-endian הכתובת הנמוכה מקבלת את הבית שתורם הכי מעט לערך המספר, ובשיטת big-endian היא מקבלת דווקא את הבית שתורם הכי הרבה. מעבדי x86 עובדים ב-little-endian, וברשת מקובל big-endian, שמכונה גם סדר הבתים של הרשת, ולכן קוד רשת ב-C מעביר ערכים דרך htons ו-htonl לפני שליחה.
| היסט | little-endian (למשל x86) | big-endian (סדר הרשת) |
|---|---|---|
| 0 | 78 | 12 |
| 1 | 56 | 34 |
| 2 | 34 | 56 |
| 3 | 12 | 78 |
הדרך החוקית להציץ בבתים של משתנה היא מצביע ל-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;
}בחרו תשובה כדי לראות את ההסבר
הסבר: ב-little-endian הבית הפחות משמעותי של 0x0A0B0C0D, כלומר 0D, נשמר בכתובת הנמוכה, ולכן b[0] הוא 0D, ו-b[1] הוא הבית הבא בחשיבות, 0C. התשובה 0A 0B נכונה רק על מעבד big-endian, שבו הבית המשמעותי ביותר יושב ראשון. התשובה 0C 0D מזהה נכון את הבתים הנמוכים אבל הופכת את סדר הקריאה שלהם.
טבלת באגים נפוצים ב-C
הטבלה מרכזת טעויות שחוזרות אצל מי שעובר משפה עילית ל-C. ברובן הקומפיילר לא עוצר אתכם, ולכן כדאי לזהות אותן לפי המראה שלהן בקוד.
| הבאג | איך הוא נראה | מה קורה | התיקון |
|---|---|---|---|
| אין מקום לתו הסוגר | char name[5]; strcpy(name, "hello"); | שישה בתים נכתבים למערך של חמישה, וזו גלישת חוצץ | להקצות strlen + 1 בתים, או להשתמש בפונקציה שמקבלת את גודל היעד |
sizeof על פרמטר | sizeof(arr) בתוך פונקציה שקיבלה מערך | מתקבל גודל של מצביע ולא של המערך | להעביר את האורך כפרמטר נפרד |
| פונקציה שמחזירה מצביע למערך שלה | return buf; כש-buf הוא מערך מקומי | המצביע מפנה למקום במחסנית שכבר לא שייך לפונקציה | להקצות ב-malloc, או לקבל חוצץ מהפונקציה שקוראת |
שימוש אחרי free | free(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
זה סדר העבודה שאנחנו ממליצים עליו. כל שלב מסתיים כשהתנאי שבו מתקיים:
- לנבא לפני שמריצים. על כל קטע קוד כותבים על דף מה יודפס, ורק אחר כך מקמפלים ומשווים. השלב הושלם כשאתם צודקים ברוב הקטעים בלי להריץ.
- לקמפל עם אזהרות. מריצים
gcc -Wall -Wextraוקוראים כל אזהרה עד הסוף. בגרסה עדכנית של gcc, שלוש מתוך שש השאלות במאמר מקבלות אזהרה שמצביעה בדיוק על המלכודת. השלב הושלם כשאתם יודעים להסביר כל אזהרה שקיבלתם. - לתת לכלי לתפוס באגים של זיכרון. בקוד עם מצביעים וזיכרון דינמי מוסיפים
-fsanitize=address, שזמין ב-gcc וב-clang ברוב התקנות Linux. הוא עוצר על קריאה מחוץ למערך ועל שימוש אחריfree. השלב הושלם כשתרגילי הזיכרון שלכם עוברים בלי הודעות שגיאה מהכלי. - לכתוב לבד שלוש פונקציות קטנות.
strlenמשלכם, העתקת מחרוזת שמקבלת את גודל היעד, ופונקציה שסופרת ביטים דולקים במספרunsigned. השלב הושלם כשכל אחת עובדת גם על קלט ריק וגם על קלט בגודל המקסימלי. - לפתוח כל שאלה בהנחות. בשאלות על גדלים או על סדר בתים כותבים קודם כמה בתים יש ב-
int, כמה במצביע ובאיזה סדר הבתים נשמרים. השלב הושלם כשזה הדבר הראשון שאתם עושים בלי לחשוב. - לסמן בשאלון רק מה שהסברתם. מושג כמו 'מצביע' או 'ערימה' מסמנים רק אם תוכלו להסביר אותו בעל פה, למשל מה ההבדל בין מערך למצביע. ההיגיון מאחורי הכלל מוסבר בעמוד על השאלון.
להמשיך לתרגל
השאלות במאמר נכתבו לתרגול הנושאים האלה, ולא נלקחו מהמבחן. מחוץ לצה"ל אף אחד לא יודע מה בדיוק נשאל בו, ולכן המטרה היא לחזק את הקריאה הזהירה של קוד ולא לשנן תשובות. עוד שאלות בכמה תחומים, כולן עם הסבר, נמצאות בעמוד השאלות לדוגמה.
מי שרוצה להמשיך יכול לתרגל לפי תחומי ידע ולפתור תרגילי קוד עם משוב אוטומטי במרכז התרגול של גאמא קוד. הסטים הקלים פתוחים אחרי הרשמה, והקשים יותר בתשלום.
שאלות נפוצות
האם חייבים לדעת C כדי להתקבל לגאמא סייבר?
לא פורסמה דרישה כזו. אין ציפייה מהמועמדים להכיר את כל נושאי מבחני הידע, ו-C היא רק אחד מהם. מי שחזק ב-Python או ב-Java יכול להתמקד בהן, בתנאי שהידע בנוי לפני יום המבחנים.
על איזה קומפיילר ואיזה תקן של C השאלות מתבססות?
זה לא פורסם. לכן כל שאלה במאמר מציינת את ההנחות שלה (גודל int, גודל מצביע, סדר בתים), כל קטעי הקוד קומפלו ב-gcc בתקן C99, ואלה שיש בהם main גם הורצו כדי לוודא שהם מדפיסים את מה שהתשובה אומרת.
האם בסדנה המעשית כותבים ב-C?
ייתכן שבחלק מהמחזורים משימות הקוד בסדנה נכתבות בשפות עיליות כמו Java או C#, עם דגש על תכנות מונחה עצמים. לא ידוע שהסדנה דורשת C, ותוכן הסדנה לא פורסם.
מה כדאי ללמוד קודם: מצביעים או פעולות על ביטים?
מצביעים ומחרוזות קודם. הם הבסיס להבנת המחסנית, הערימה וגלישת חוצץ. פעולות על ביטים נשענות בעיקר על קריאה של בסיס 2 ובסיס 16, ואפשר להשלים אותן אחר כך.
האם השאלות כאן משקפות את רמת הקושי ביום המבחנים?
אין לנו דרך לדעת, וגם לאף אחד אחר מחוץ לצה"ל אין. השאלות נכתבו כדי לתרגל קריאה זהירה של קוד בנושאים שבהם C נבדלת משפות אחרות, לא כדי לחקות מבחן כלשהו.
להמשך קריאה
עודכן לאחרונה: 2026-11-12