דלג לתוכן
נושאים
  • 1 בסיסי C
    1.1

    main, printf & פונקציות

    כל תוכנית C מתחילה בmain. #include <stdio.h> כולל קובץ ראש כדי שתוכל להשתמש בprintf להדפסה. פונקציה היא בלוק עם שם שמכיל הוראות; \n מייצר שורה חדשה. main מחזיר 0 כדי לסמן "הצלחה".

    #include <stdio.h>
    
    void greet(void) {
        printf("Hello, world!\n");
    }
    
    int main(void) {
        greet();
        printf("I am learning C.\n");
        return 0;
    }
    
    כל תוכנית C רצה מה-main לאחר כלולת קבצי ראש
    כל תוכנית C רצה מה-main לאחר כלולת קבצי ראש
    1.2

    משתנים, סוגים וחישובים

    C דורשת סוג לכל משתנה: int (שלם), double (מנוף צף), char (תווה אחד). printf משתמש בספק פורמט — %d, %f, %c — עבור כל ערך. / בין שני שלמים היא חילוק שלם; % הוא השארית.

    #include <stdio.h>
    
    int main(void) {
        int n = 17;
        double pi = 3.14;
        char grade = 'A';
        printf("%d %.2f %c\n", n, pi, grade);   // 17 3.14 A
        printf("%d %d\n", 7 / 2, 7 % 2);        // 3 1
        return 0;
    }
    

    מחרוזת הפורמט מנעה גם הדפסה וגם קריאה:

    ספן סוג דוגמת תוצאה
    %d int 17
    %f double (%.2f = 2 מקומות עשרוניים) 3.14
    %c char A
    %s מחרוזת Mei
    %zu גודל (מ-sizeof / strlen) 3
    %x unsigned int, מודפס בבסיס 16 ff

    scanf("%d", &n) קורא int דרך כתובתו (שים לב ל&). פורמטים של קלט ופלט אינם זהים: printf("%f", x) מדפיץ double, אך scanf("%lf", &x) קורא double; קלט %f דורש float *. בדוק את מספר הפריטים שהוקצו בהצלחה. האח sscanf מפרק ערכים מתוך מחרוזת טקסט:

    #include <stdio.h>
    
    int main(void) {
        char line[] = "Mei 88";
        char name[20];
        int score;
        if (sscanf(line, "%19s %d", name, &score) != 2) return 1;
        printf("%s scored %d\n", name, score);   // Mei scored 88
        return 0;
    }
    
    1.3

    הערות סגנון

    תגובה היא הערה לאנשים; המתרגם מתעלם ממנה. השתמשו ב-// לקו אחד וב-/* ... */ לחסימת טקסט. ניקוד ותוארים ברורים הופכים את הקוד לקריא.

    #include <stdio.h>
    
    int main(void) {
        // a single-line comment
        /* a block
           comment */
        int total = 3 + 4;       // clear names help
        printf("%d\n", total);   // 7
        return 0;
    }
    

    שגיאות נפוצות

    • הצהרות והצהרות ביטוי נסגרות ב;; בלוק מורכב { ... } אינו זקוק לנקודה-פסיקה נוספת. main אמור להחזיר int (return 0;).
    • printf דורש שורת פורמט: %d עבור int, %f עבור double, ו-\n עבור שורה חדשה.
    • פורמט שגוי כמו %d עבור double גורם התנהגות לא מוגדרת; אין הבטחה שהוא ידפיס רק פסולת. התאם את סוג הארגומנט.
  • 2 בחירה
    2.1

    if / else

    if רץ בלוק כאשר תנאי הוא נכון. תנאי נבדק כמספר: 0 הוא שקר וכל ערך שאינו אפס הוא נכון. (C99's <stdbool.h> מוסיף סוג בוליאני, bool עם true וfalse, אך אלו עדיין הן 1 ו0 מתחת.) בחירת שרשרת עם else if וelse. השוו עם ==, !=, <, >, <=, >=.

    #include <stdio.h>
    
    int main(void) {
        int score = 72;
        if (score >= 90) {
            printf("A\n");
        } else if (score >= 60) {
            printf("Pass\n");
        } else {
            printf("Fail\n");
        }
        return 0;
    }
    
    if בוחר את הענף האמת; else את הענף השגוי
    if בוחר את הענף האמת; else את הענף השגוי
    2.2

    מתג

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

    #include <stdio.h>
    
    int main(void) {
        int day = 3;
        switch (day) {
            case 1: printf("Mon\n"); break;
            case 2: printf("Tue\n"); break;
            case 3: printf("Wed\n"); break;
            default: printf("Other\n");
        }
        return 0;
    }
    

    שגיאות נפוצות

    • if (x = 5) משתנה ומתמיד אמת; השתמשו ב-== להשוואה.
    • סיום מקרה switch עם break; כאשר נפילה למקרה הבא אינה מתכוונת.
    • 0 היא שגויה וכל ערך שאינו אפס הוא אמת בתנאי.
  • 3 לולאות
    3.1

    לולאות while & for

    לולאה חוזרת על בלוק. לולאת while פועלת כל עוד תנאי הוא אמת. לולאת for מארגנת את ההתחלה, הבדיקה וההגברה (i++) בשורה אחת — הטובה ביותר כאשר ידוע כמה פעמים לחזור.

    #include <stdio.h>
    
    int main(void) {
        int i = 1;
        while (i <= 3) {
            printf("%d ", i);
            i++;
        }
        printf("\n");                    // 1 2 3
        for (int j = 0; j < 5; j++) {
            printf("%d ", j);
        }
        printf("\n");                    // 0 1 2 3 4
        return 0;
    }
    
    while בודק תנאי; for סופר עם צעד
    while בודק תנאי; for סופר עם צעד
    3.2

    הצטברות

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

    #include <stdio.h>
    
    int main(void) {
        int total = 0;
        for (int i = 1; i <= 5; i++) {
            total += i;            // 1 + 2 + 3 + 4 + 5
        }
        printf("%d\n", total);     // 15
        return 0;
    }
    
    3.3

    לולאות מצטבקות ודפוסים

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

    #include <stdio.h>
    
    int main(void) {
        for (int row = 0; row < 3; row++) {
            for (int col = 0; col < 3; col++) {
                printf("*");
            }
            printf("\n");
        }
        return 0;
    }
    

    שגיאות נפוצות

    • for (i = 0; i < n; i++) מתבצע n פעמים; נקודה-פסיקה מיד אחרי for (...) יוצרת לולאה ריקה.
    • לולאת while שהתנאי שלה לעולם לא הופך לשגויה לולאה לנצח.
    • הכריזו את הסופר (int i) לפני או בתוך כותרת ה-for.
  • 4 פונקציות
    4.1

    פרמטרים וערכי החזרה

    פונקציה לוקחת פרמטרים (כניסות) וחוזרת ערך חזרה. סוג החזרה מגיע קודם (int, double, …); void פירושה שהיא מחזירה דבר כלל.

    #include <stdio.h>
    
    int square(int x) {        // x is a parameter
        return x * x;          // hand back a value
    }
    
    int main(void) {
        int r = square(5);
        printf("%d\n", r);     // 25
        return 0;
    }
    
    פרמטרים כניסה; ערך חזרה יציאה
    פרמטרים כניסה; ערך חזרה יציאה
    4.2

    פרוטוטיפים וטווח

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

    #include <stdio.h>
    
    int add(int a, int b);     // prototype: declared before use
    
    int main(void) {
        printf("%d\n", add(3, 4));   // 7
        return 0;
    }
    
    int add(int a, int b) {    // definition comes later
        int sum = a + b;       // sum is local to add
        return sum;
    }
    

    שגיאות נפוצות

    • פונקציה המשמשת לפני שהוגדרה זקוקה לגרסה מקדימה מעל main.
    • ארגומנטים עוברים בערך — שינויים בתוך פונקציה אינם משפיעים על הקורא אלא אם כן עוברת נקודת היפנית (pointer).
    • משתנה המוגדר בתוך פונקציה הוא מקומי לה.
  • 5 מערכים
    5.1

    מערךים בעלי ממד 1

    מעריך מחזיק מספר ערכים מאותו סוג. אינדקס מתחיל ב0. C אינו אוגר את אורך המערכת, לכן טריק נפוץ מחשב את מספר האלמנטים: sizeof(a) / sizeof(a[0]).

    #include <stdio.h>
    
    int main(void) {
        int scores[3] = {88, 71, 95};
        printf("%d\n", scores[0]);     // 88
        scores[1] = 100;
        printf("%d\n", scores[1]);     // 100
        int n = sizeof(scores) / sizeof(scores[0]);
        printf("%d\n", n);             // 3
        return 0;
    }
    
    מקושי מערכת ממוספרים החל מ-0
    מקושי מערכת ממוספרים החל מ-0
    5.2

    אלגוריתמים למערכים

    עבור על מערכת עם לולאת for כדי למצוא מקסימום, סכום או ספירה. תמיד לולאה מהערך 0 ועד הערך n - 1.

    #include <stdio.h>
    
    int main(void) {
        int a[] = {3, 9, 2, 7};
        int n = sizeof(a) / sizeof(a[0]);
        int max = a[0], total = 0;
        for (int i = 0; i < n; i++) {
            if (a[i] > max) max = a[i];
            total += a[i];
        }
        printf("%d %d\n", max, total);   // 9 21
        return 0;
    }
    
    5.3

    מערךים בעלי ממד 2

    מערך בעל ממד 2 הוא טבלה של שורות ועמודות: grid[row][col]. השתמש בשני לולאות מקוננות כדי לבקר בכל תא.

    #include <stdio.h>
    
    int main(void) {
        int grid[2][3] = {{1, 2, 3}, {4, 5, 6}};
        printf("%d\n", grid[1][2]);    // 6
        for (int r = 0; r < 2; r++) {
            for (int c = 0; c < 3; c++) {
                printf("%d ", grid[r][c]);
            }
        }
        printf("\n");                  // 1 2 3 4 5 6
        return 0;
    }
    

    שגיאות נפוצות

    • C אינו בודק גבולות מערכת: כתיבה בa[n] במערכת בגודל n היא התנהגות לא מוגדרת (undefined behaviour).
    • אינדקסים תקפים רצים מהערך 0 עד הערך n - 1.
    • ברוב הביטויים ממשק (array) הופך למצביע לאלמנט הראשון שלו, אך הממשק עצמו אינו מצביע. sizeof(a) מחזיר את גודל הבייטים כולו עבור ממשק בפועל; פרמטר ממשק מותאם למצביע, ולכן הפונקציה זקוקה לאורך מסופק בנפרד.
  • 6 רמזים
    6.1

    &, * והעברה באמצעות נקודת היפנית

    נקודת היפנית אחסנת כתובת של משתנה. &x נותן את הכתובת של x; *p מבצע פירוק (dereference) לנקודת ההיפנית — הוא קורא או כותב את הערך האחסן שם. העברת נקודת היפנית מאפשרת לפונקציה לשנות את המשתנה של הקורא (pass-by-pointer).

    נקודת היפנית אחסנת כתובת; פירוקה עוקב אחרי החץ לערך
    מצביע מאחסן כתובת; גישה דרכו עוקבת אחרי החץ לערך
    #include <stdio.h>
    
    void addOne(int *p) {     // p holds an address
        *p = *p + 1;          // change the value at that address
    }
    
    int main(void) {
        int x = 10;
        int *ptr = &x;        // & takes the address of x
        printf("%d\n", *ptr); // * reads the value: 10
        addOne(&x);
        printf("%d\n", x);    // 11 — changed through the pointer
        return 0;
    }
    

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

    #include <stdio.h>
    
    void swap_values(int a, int b) {      // copies: the caller sees nothing
        int t = a; a = b; b = t;
    }
    
    void swap_pointers(int *a, int *b) {  // addresses: the swap is real
        int t = *a; *a = *b; *b = t;
    }
    
    int main(void) {
        int x = 1, y = 2;
        swap_values(x, y);
        printf("%d %d\n", x, y);   // 1 2  (unchanged!)
        swap_pointers(&x, &y);
        printf("%d %d\n", x, y);   // 2 1  (swapped)
        return 0;
    }
    

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

    #include <stdio.h>
    
    int main(void) {
        int a[] = {10, 20, 30};
        int *p = a;                 // same as &a[0]
        printf("%d\n", *p);         // 10
        printf("%d\n", *(p + 2));   // 30 — same as a[2]
        return 0;
    }
    
    • NULL הוא המצביע שמצביע ללא כלום — בדק אותו לפני הגישה.

    שגיאות נפוצות

    • &x היא הכתובת של x; *p הוא הערך הארוז בp.
    • לעולם אל תשתמש ב*p על מצביע לא מוזמן או NULL — זה יגרם לקריסה או להפרעת זיכרון.
    • כדי לשנות משתנה של קורא, העבר את הכתובת שלו וכתוב דרך המצביע.
  • 7 מחרוזות
    7.1

    מערכי Char ומסוף נול

    מחרוזת C היא מערך של char. כל מחרוזת מסתיימת במסוף נול נסתר '\0', שמסמן היכן היא נפסקת. strlen (מ-<string.h>) סופר תווים עד מסוף זה '\0'. הדפס מחרוזת שלמה עם %s ותווה אחד עם %c.

    #include <stdio.h>
    #include <string.h>
    
    int main(void) {
        char name[] = "Mei";            // 'M', 'e', 'i', '\0'
        printf("%s\n", name);           // Mei
        printf("%zu\n", strlen(name));  // 3 (stops at '\0')
        printf("%c\n", name[0]);        // M
        return 0;
    }
    
    מחרוזת C היא מערך char הנסתיים במסוף נול נסתר
    מחרוזת C היא מערך char הנסתיים במסוף נול נסתר

    ניתן לעבור על מחרוזת באמצעות לולאה עד שתגיע ל-'\0'.

    #include <stdio.h>
    
    int main(void) {
        char word[] = "banana";
        int count = 0;
        for (int i = 0; word[i] != '\0'; i++) {
            if (word[i] == 'a') count++;
        }
        printf("%d\n", count);   // 3
        return 0;
    }
    
    7.2

    הספרייה string.h

    #include <string.h> מספק לך את כלים שגרתיים למחרוזות:

    פונקציה ביצוע
    strlen(s) האורך, בלי לספור את המסוף
    strcpy(dst, src) העתקה — dst חייב להיות גדול מספיק
    strcat(dst, src) הוספת src בסוף dst
    strcmp(a, b) השוואה: 0 כאשר שוות, אחרת שלילי / חיובי
    #include <stdio.h>
    #include <string.h>
    
    int main(void) {
        char full[40];
        strcpy(full, "Mei");           // full is now "Mei"
        strcat(full, " Chen");         // append -> "Mei Chen"
        printf("%s (%zu)\n", full, strlen(full));       // Mei Chen (8)
        printf("%d\n", strcmp("apple", "apple") == 0);  // 1 (equal)
        return 0;
    }
    
    • strcmp מחזירה 0 עבור שוויון, ולכן הבדיקה היא strcmp(a, b) == 0 — לעולם לא a == b.
    • מערך היעד חייב להכיל מקום לתוצאה בנוסף למסוף.

    שגיאות נפוצות

    • מחרוזת C דורשת בייט נוסף למסייר \0: מילה בעלת 5 אותיות דורשת char[6].
    • העתק והשווה מחרוזות עם strcpy / strcmp, לא עם = / ==.
    • שכחון את המסייר \0 גורם לprintf("%s", ...) להמשיך מעבר לסוף הטקסט.
  • 8 מבנים (structs)
    8.1

    מבנה (struct), typedef, . מול ->

    מבנה (struct) מקבץ ערכים קשורים לסוג אחד. כל ערך הוא חבר. typedef נותן למבנה שם קצר כך שתוכל לכתוב Dog במקום struct Dog. השתמש ב. על ערך מבנה, אך ב-> על מצביע למבנה.

    #include <stdio.h>
    
    typedef struct {
        char name[20];
        int age;
    } Dog;
    
    int main(void) {
        Dog d = {"Rex", 3};
        printf("%s is %d\n", d.name, d.age);   // Rex is 3   (. on a value)
    
        Dog *p = &d;
        p->age = 4;                            // -> on a pointer
        printf("%s is %d\n", d.name, d.age);   // Rex is 4
        return 0;
    }
    

    שגיאות נפוצות

    • השתמש ב-. על ערך מבנה, וב--> על רמז למבנה.
    • typedef מאפשר לך לוותר על המילה struct בהצהרת סוג; ללא זה תכתוב struct Point p;.
    • החלפת מבנה אחד באחר מעתיקה את כל השדות שלו.
    . עבור ערכי מבנה; -> עבור מצביעים למבנים
    . עבור ערכי מבנה; -> עבור מצביעים למבנים
  • 9 זיכרון דינמי
    9.1

    malloc, free & realloc

    malloc מקצה זיכרון על הגוש בזמן הרצה וחוזר עליו עם מצביע. realloc משנה את גודל חסימה זו; free מחזירה אותו בחזרה. כל malloc זקוק ל-free התואם לו, אחרת תקבלו דליפת זיכרון. אלו חיים ב-<stdlib.h>.

    משתנים מקומיים גרים בערימה; זיכרון malloc גר בגרעין עד שתשחרר אותו
    משתנים מקומיים גרים בערימה; זיכרון malloc גר בגרעין עד שתשחרר אותו
    #include <stdio.h>
    #include <stdlib.h>
    
    int main(void) {
        int n = 3;
        int *a = malloc(n * sizeof(int));    // room for 3 ints
        if (a == NULL) return EXIT_FAILURE;
        for (int i = 0; i < n; i++) a[i] = i * 10;
    
        int *grown = realloc(a, 4 * sizeof *a); // positive size
        if (grown == NULL) {
            free(a);
            return EXIT_FAILURE;
        }
        a = grown;
        a[3] = 30;
    
        for (int i = 0; i < 4; i++) printf("%d ", a[i]);
        printf("\n");                        // 0 10 20 30
    
        free(a);                             // hand the memory back
        return 0;
    }
    
    • calloc(n, size) הקצית מערך כמו malloc AND ממלא אותו באפסים.

    שגיאות נפוצות

    • כל malloc זקוק ל-free התואם לו; שכחת הפקת זיכרון (free) גורמת לדליפת זיכרון.
    • שימוש בזיכרון לאחר free ("שימוש-אחרי-שחרור") הוא באג קשה.
    • בדוק שהmalloc לא החזיר NULL לפני שימוש בזיכרון.

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

  • 10 מבני נתונים
    10.1

    רשימות מקשרות

    רשימה מקשרת היא שרשרת של צמתים. כל צומח מכיל ערך ומצביע לצומח הnext; האחרון מצביע לNULL. בניגוד למערכת, היא גדלה בצומח אחד בכל פעם עם malloc. תמיד free את כל הצמתים כשנסיימת.

    רשימה מקשרת: כל צומח מכיל ערך ומצביע הבא, מסתיים ב-NUL
    רשימה מקושרת: כל נקודה מחזירה ערך ומצביע לנקודה הבאה, והסיום הוא NULL
    #include <stdio.h>
    #include <stdlib.h>
    
    typedef struct Node {
        int value;
        struct Node *next;
    } Node;
    
    int main(void) {
        Node *head = NULL;
        for (int v = 10; v <= 30; v += 10) {   // prepend 10, 20, 30
            Node *n = malloc(sizeof(Node));
            n->value = v;
            n->next = head;
            head = n;
        }
        for (Node *p = head; p != NULL; p = p->next) {
            printf("%d ", p->value);           // 30 20 10
        }
        printf("\n");
    
        while (head != NULL) {                 // free the whole list
            Node *t = head;
            head = head->next;
            free(t);
        }
        return 0;
    }
    
    10.2

    ערימות ותורים

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

    #include <stdio.h>
    
    int main(void) {
        int stack[10];
        int top = 0;                       // next free slot
        stack[top++] = 1;                  // push
        stack[top++] = 2;
        stack[top++] = 3;
        while (top > 0) {
            printf("%d ", stack[--top]);   // pop: 3 2 1
        }
        printf("\n");
        return 0;
    }
    
    #include <stdio.h>
    
    int main(void) {
        int queue[10];
        int front = 0, back = 0;
        queue[back++] = 1;                       // enqueue
        queue[back++] = 2;
        queue[back++] = 3;
        while (front < back) {
            printf("%d ", queue[front++]);       // dequeue: 1 2 3
        }
        printf("\n");
        return 0;
    }
    

    שגיאות נפוצות

    • ברשימה מקושרת, לעולם אל תאבד את מצביע הhead, אלא כל הרשימה תהייה לא נגישה.
    • שחרר כל נקודה כשסיימת, תוך כדי העברה על הרשימה לפני ניתוק הקישורים.
    • בדוק רשימה ריקה (ראש NULL) לפני ביצוע הפעלת הוצאה.
  • 11 חיפוש, מיון ורצוריות
    11.1

    חיפוש ליניארי וחיפוש בנארי

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

    #include <stdio.h>
    
    int linear(int a[], int n, int target) {
        for (int i = 0; i < n; i++)
            if (a[i] == target) return i;
        return -1;
    }
    
    int binary(int a[], int n, int target) {
        int lo = 0, hi = n - 1;
        while (lo <= hi) {
            int mid = (lo + hi) / 2;
            if (a[mid] == target) return mid;
            else if (a[mid] < target) lo = mid + 1;
            else hi = mid - 1;
        }
        return -1;
    }
    
    int main(void) {
        int a[] = {2, 5, 8, 12, 16, 23};
        int n = sizeof(a) / sizeof(a[0]);
        printf("%d %d %d\n", linear(a, n, 12), binary(a, n, 12), binary(a, n, 9));
        return 0;   // 3 3 -1
    }
    
    סריקה ליניארית בודקת הכל; בינארית מחצית טווח ממוין
    חיפוש ליניארי סורק הכל; בנארי חוצה טווח ממוין
    11.2

    מיון

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

    #include <stdio.h>
    
    int main(void) {
        int a[] = {5, 2, 9, 1, 7};
        int n = sizeof(a) / sizeof(a[0]);
        for (int i = 0; i < n - 1; i++) {
            for (int j = 0; j < n - 1 - i; j++) {
                if (a[j] > a[j + 1]) {
                    int t = a[j]; a[j] = a[j + 1]; a[j + 1] = t;
                }
            }
        }
        for (int i = 0; i < n; i++) printf("%d ", a[i]);
        printf("\n");   // 1 2 5 7 9
        return 0;
    }
    
    11.3

    רקורסיה

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

    #include <stdio.h>
    
    int factorial(int n) {
        if (n <= 1) return 1;          // base case
        return n * factorial(n - 1);   // recursive call
    }
    
    int main(void) {
        printf("%d\n", factorial(5));  // 120
        return 0;
    }
    

    שגיאות נפוצות

    • חיפוש בנארי דורש מערך ממוין; רקורסיה דורשת מקרה בסיסי.
    • לכל קריאה רקורסיבית יש להתקרב יותר למקרה הבסיסי, אלא תתרחש התפרצות ערימה.
    • מיון בועות ומיון הכנסה הם O(n²) — טוב ללמידה, איטי בקנה מידה גדול.
  • 12 קבצים ושגיאות
    12.1

    קבצי טקסט

    fopen מחזירה מצביע לקובץ; מחרוזת המצב אומרת מה לעשות — "w" כתיבה, "r" קריאה, "a" הצרפה. כתוב עם fprintf, קרא עם fscanf, ובכל פעם סיים עם fclose.

    #include <stdio.h>
    
    int main(void) {
        FILE *out = fopen("scores.txt", "w");   // open for writing
        if (out == NULL) {
            perror("scores.txt");
            return 1;
        }
        fprintf(out, "Alice 80\nBob 95\n");
        fclose(out);
    
        FILE *in = fopen("scores.txt", "r");    // open for reading
        if (in == NULL) {
            perror("scores.txt");
            return 1;
        }
        char name[20];
        int score;
        while (fscanf(in, "%19s %d", name, &score) == 2) {   // %19s leaves room for '\0'
            printf("%s -> %d\n", name, score);
        }
        fclose(in);
        return 0;
    }
    
    fopen → קריאה/כתיבה → fclose
    fopen → קריאה/כתיבה → fclose
    12.2

    טיפול בשגיאות עם קודי חזרה

    ל-C אין חריגות מובנות. פונקציה יכולה לדווח על תוצאותיה דרך קוד השבה; בדוק את כללי הפונקציה לפני השימוש בתוצאה. הדוגמה למטה משתמשת ב-0 להצלחה וב--1 לכישלון. במקום זאת, fopen מחזיר מצביע לשטף (stream pointer), או NULL כאשר כושל.

    #include <stdio.h>
    
    // returns 0 on success, -1 if the divisor is 0
    int safe_divide(int a, int b, int *result) {
        if (b == 0) return -1;          // error code
        *result = a / b;
        return 0;                       // success
    }
    
    int main(void) {
        int r;
        if (safe_divide(10, 2, &r) == 0)
            printf("10 / 2 = %d\n", r);          // 10 / 2 = 5
        if (safe_divide(10, 0, &r) != 0)
            printf("cannot divide by zero\n");   // error reported
        return 0;
    }
    

    שגיאות נפוצות

    • לוודא ש-fopen לא החזיר NULL לפני הקריאה או הכתיבה.
    • תמיד סגור fclose קובץ לאחר השלמת העבודה.
    • החזר קוד שאינו אפס מmain כדי לסמן שגיאה לקורא.
  • 13 ביטים ומידע
    13.1

    ביטים, בינארי ותפעולי ביט

    ביט הוא 0 או 1 בודד; מספרים מאוחסנים בבינארי. תפעולי ביט פועלים ישירות על הביטים: & AND, | OR, ^ XOR, << הזזה שמאלה (×2 בכל שלב), >> הזזה ימינה (÷2).

    #include <stdio.h>
    
    int main(void) {
        int a = 12;              // 1100
        int b = 10;              // 1010
        printf("%d\n", a & b);   // 8   AND  -> 1000
        printf("%d\n", a | b);   // 14  OR   -> 1110
        printf("%d\n", a ^ b);   // 6   XOR  -> 0110
        printf("%d\n", a << 1);  // 24  left shift
        printf("%d\n", a >> 1);  // 6   right shift
        return 0;
    }
    

    מערכת מצומצמת (בסיס 16) כותבת בינארי בצורה דחוסה: דיgit אחד במצומצת הוא בדיוק ארבעה ביטים. כתוב ליטרלים מצומצמים עם 0x; הדפס עם %x:

    #include <stdio.h>
    
    int main(void) {
        printf("%d\n", 0xFF);   // 255  (0x marks a hex literal)
        printf("%x\n", 255);    // ff
        printf("%x\n", 12);     // c
        return 0;
    }
    
    תפעולי ביט פועלים על הביטים של שלמים
    תפעולי ביט פועלים על הביטים של שלמים
    13.2

    ריצות-לונג'ית אנקודינג

    הצפנת אורך-רוץ (RLE) היא שיטת דחיסה פשוטה: החלף כל רצף של תווים חוזרים בספנית ובאות. השיטה היא ללא איבוד נתונים — המקורי ניתן לשחזור במלואו.

    #include <stdio.h>
    #include <string.h>
    
    int main(void) {
        char *s = "aaabbc";
        int n = strlen(s);
        for (int i = 0; i < n; ) {
            char c = s[i];
            int run = 0;
            while (i < n && s[i] == c) { run++; i++; }
            printf("%d%c", run, c);     // 3a2b1c
        }
        printf("\n");
        return 0;
    }
    

    שגיאות נפוצות

    • & הוא AND בינארי ו&& הוא AND לוגי — אל תבלבנו ביניהם.
    • הזזה שמאלה << 1 מכפילה בערך; הזזה ימינה >> 1 מחלקת בערך למחצה.
    • ביט n יש לו ערך 1 << n (C אין לה תפעול ** חזקה); בדוק ביט עם (x >> n) & 1.
  • 14 מעבד קדם-שלב ומוגבלים
    14.1

    מעבד קדם-שלב, const, static, enum

    ה-preprocessor פועל לפני ההרכבה. #define יוצר מקרו — החלפת טקסט פשוטה בכל מקום. const יוצר קבועה שלא ניתן לשנות. static בתוך פונקציה שומר על ערך משתנה בין קריאות. ערך enum (enum) מיימר קבוצה של שלמים התחילים ב0.

    #include <stdio.h>
    
    #define MAX 100                     // macro: text replaced before compiling
    
    enum Color { RED, GREEN, BLUE };    // named integers 0, 1, 2
    
    int next_id(void) {
        static int count = 0;           // keeps its value between calls
        count++;
        return count;
    }
    
    int main(void) {
        const double PI = 3.14;         // cannot be changed
        printf("%d %.2f\n", MAX, PI);            // 100 3.14
        printf("%d %d %d\n", RED, GREEN, BLUE);  // 0 1 2
        int a = next_id();
        int b = next_id();
        printf("%d %d\n", a, b);                 // 1 2
        return 0;
    }
    

    תוכניות גדולות מחולקות בין קבצים: הכרזות הולכות בקובץ כותרת (mine.h), שנכלל עם #include "mine.h" — סימני ציטוט מתכוונים לקובץ שלך, < > מתכוון לספריית הסטנדרט. מגן כליל (#ifndef MINE_H / #define MINE_H / #endif) מונע כתיבת כותרת פעמיים.

    שגיאות נפוצות

    • #define מבצע החלפת טקסט פשוטה ללא בדיקת סוגים; עטוף גופי מקרו וארגומנטים בסוגריים.
    • ערך const לא ניתן לשינוי לאחר שהוגדר.
    • משתנה מקומי static שומר על ערכו בין קריאות לפונקציה.
    #define, const, enum, וstatic שומרים על קוד ברור
    #define, const, enum, וstatic שומרים על קוד ברור

היכנס או צור חשבון

IGCSE, A-Level & AP