אופרטורים ב-C: אריתמטיים, לוגיים וסדר קדימויות

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

אופרטורים אריתמטיים

#include <stdio.h>

int main(void) {
    int a = 17, b = 5;

    printf("a + b  = %d\n", a + b);   /* 22 */
    printf("a - b  = %d\n", a - b);   /* 12 */
    printf("a * b  = %d\n", a * b);   /* 85 */
    printf("a / b  = %d\n", a / b);   /* 3: חילוק שלמים! */
    printf("a %% b  = %d\n", a % b);  /* 2: השארית */
    printf("-a     = %d\n", -a);      /* מינוס אונרי */
    return 0;
}

(%% במחרוזת הפורמט מדפיס סימן אחוז מילולי: % לבד היה פותח format specifier.)

חמשת האופרטורים האריתמטיים הבינאריים הם + - * / %, ועוד - אונרי לשלילה ו-+ שלמעשה לא עושה כלום.

המלכודת של חילוק שלמים

a / b עם שני מספרים שלמים מבצע חילוק שלמים וזורק את השארית. אין עיגול: התוצאה נחתכת לכיוון אפס.

#include <stdio.h>

int main(void) {
    int total = 7, count = 2;

    printf("7 / 2         = %d\n", total / count);          /* 3 */
    printf("7 / 2.0       = %f\n", total / 2.0);            /* 3.5 */
    printf("(double)7 / 2 = %f\n", (double)total / count);  /* 3.5 */

    double wrong = total / count;      /* החילוק קורה קודם, כ-int */
    printf("wrong average = %f\n", wrong);   /* 3.000000 */
    return 0;
}

המקרה האחרון הוא הבאג ששורד עד הפרודקשן. השמה ל-double לא עוזרת: החילוק total / count כבר הסתיים, וכבר הוא int, לפני שההשמה קורית. התיקון הוא להפוך אופרנד אחד לנקודה צפה בתוך הביטוי, בדרך כלל עם המרה.

שני כללים קשורים: חילוק באפס עם מספרים שלמים הוא התנהגות לא מוגדרת ובדרך כלל מקריס את התוכנית, ו-INT_MIN / -1 גולש.

אופרטור המודולו

% נותן את השארית ועובד רק על מספרים שלמים:

#include <stdio.h>

int main(void) {
    for (int i = 1; i <= 10; i++) {
        if (i % 2 == 0) {
            printf("%d is even\n", i);
        } else {
            printf("%d is odd\n", i);
        }
    }

    int seconds = 3725;
    printf("\n%d seconds = %dh %dm %ds\n",
           seconds, seconds / 3600, (seconds % 3600) / 60, seconds % 60);
    return 0;
}

בדיקה של x % 2 == 0 לזוגיות ושימוש ב-% n כדי לגלגל אינדקס סביב מערך הם שני השימושים היומיומיים.

עם מספרים שליליים, % של C הולך לפי הסימן של המחולק:

#include <stdio.h>

int main(void) {
    printf(" 7 %% 3 = %d\n",  7 % 3);   /*  1 */
    printf("-7 %% 3 = %d\n", -7 % 3);   /* -1, לא 2 */
    printf(" 7 %% -3 = %d\n", 7 % -3);  /*  1 */
    return 0;
}

לכן x % 2 == 1 היא בדיקה שבורה לאי-זוגיות כש-x יכול להיות שלילי: -7 % 2 הוא -1. השתמשו במקום זאת ב-x % 2 != 0.

עבור שאריות בנקודה צפה, % הוא שגיאת קומפילציה; השתמשו ב-fmod() מ-math.h.

השמה והשמה מורכבת

= שומר ערך. הצורות המורכבות משלבות פעולה עם השמירה:

#include <stdio.h>

int main(void) {
    int x = 10;

    x += 5;   printf("x += 5   -> %d\n", x);   /* 15 */
    x -= 3;   printf("x -= 3   -> %d\n", x);   /* 12 */
    x *= 2;   printf("x *= 2   -> %d\n", x);   /* 24 */
    x /= 4;   printf("x /= 4   -> %d\n", x);   /* 6  */
    x %= 4;   printf("x %%= 4   -> %d\n", x);  /* 2  */
    return 0;
}

x += 5 פירושו x = x + 5, אבל הוא מחשב את x רק פעם אחת, וזה חשוב כשהיעד הוא משהו כמו arr[compute_index()].

השמה היא בעצמה ביטוי שמחזיר את הערך שהושם, ולכן a = b = c = 0 עובד (הוא משים מימין לשמאל), ולכן הטעות של = מול == מתקמפלת בשקט.

הגדלה והקטנה

++ מוסיף אחד, -- מחסיר אחד. לכל אחד יש צורת prefix וצורת postfix:

#include <stdio.h>

int main(void) {
    int i = 5;
    int a = i++;    /* a מקבל 5 (הערך הישן), ואז i הופך ל-6 */
    printf("postfix: a = %d, i = %d\n", a, i);

    int j = 5;
    int b = ++j;    /* j הופך ל-6 קודם, ואז b מקבל 6 */
    printf("prefix:  b = %d, j = %d\n", b, j);

    int k = 5;
    k++;            /* כפקודה עצמאית, זהה ל-++k */
    printf("statement: k = %d\n", k);
    return 0;
}

כפקודה עצמאית שתי הצורות ניתנות להחלפה, ו-i++ הוא הבחירה המקובלת בכותרת של for בלי סיבה עמוקה יותר ממסורת.

מה שאסור לעשות הוא להשתמש במשתנה יותר מפעם אחת בביטוי שבו הוא גם משתנה:

int i = 5;
int x = i++ + i++;      /* התנהגות לא מוגדרת */
arr[i] = i++;           /* התנהגות לא מוגדרת */
printf("%d %d", i++, i);/* התנהגות לא מוגדרת */

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

אופרטורי השוואה

יש שישה, וכולם מפיקים int: 1 עבור אמת ו-0 עבור שקר.

#include <stdio.h>

int main(void) {
    int a = 5, b = 8;

    printf("a == b : %d\n", a == b);   /* 0 */
    printf("a != b : %d\n", a != b);   /* 1 */
    printf("a <  b : %d\n", a <  b);   /* 1 */
    printf("a >  b : %d\n", a >  b);   /* 0 */
    printf("a <= 5 : %d\n", a <= 5);   /* 1 */
    printf("a >= 9 : %d\n", a >= 9);   /* 0 */
    return 0;
}

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

שתי טעויות השוואה ייחודיות ל-C. שרשור לא עובד כמו שהמתמטיקה מרמזת: if (1 < x < 10) תמיד אמת, כי 1 < x מחושב ל-0 או 1 ואז זה מושווה ל-10. כתבו if (x > 1 && x < 10). והשוואת מחרוזות עם == משווה מצביעים, לא טקסט: השתמשו ב-strcmp מ-string.h.

אופרטורים לוגיים

#include <stdio.h>

int main(void) {
    int age = 25;
    int has_license = 1;

    if (age >= 18 && has_license) {
        printf("May drive\n");
    }

    if (age < 13 || age > 65) {
        printf("Discounted ticket\n");
    } else {
        printf("Full price\n");
    }

    printf("!has_license = %d\n", !has_license);   /* 0 */
    printf("!0 = %d\n", !0);                       /* 1 */
    return 0;
}

&& הוא AND, || הוא OR, ! הוא NOT. שלושתם מתייחסים לכל ערך שונה מאפס כאמת.

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

#include <stdio.h>

int is_safe(int *p) {
    /* אם p הוא NULL, *p אף פעם לא מחושב: ה-&& עוצר קודם. */
    return p != NULL && *p > 0;
}

int main(void) {
    int value = 7;
    printf("with a real pointer: %d\n", is_safe(&value));
    printf("with NULL:           %d\n", is_safe(NULL));
    return 0;
}

החליפו את הסדר של שתי הבדיקות האלה והקריאה עם NULL תבצע dereference למצביע null ותקרוס. קודם שמירה, אחר כך שימוש: הסדר בשרשרת && הוא חלק מהלוגיקה.

האופרטור המותנה

האופרטור היחיד ב-C עם שלושה אופרנדים בוחר בין שני ערכים:

#include <stdio.h>

int main(void) {
    int a = 12, b = 30;

    int max = (a > b) ? a : b;
    printf("max = %d\n", max);

    printf("%d item%s\n", a, (a == 1) ? "" : "s");
    return 0;
}

condition ? value_if_true : value_if_false. זה ביטוי, ולכן הוא מתאים במקומות שבהם פקודת if לא יכולה להופיע: בתוך ארגומנט של printf, באתחול. שמרו אותו קצר; ביטויים מותנים מקוננים הופכים לבלתי קריאים מהר.

אופרטורים על ביטים, בקצרה

אלה עובדים על הביטים הבודדים של מספר שלם:

#include <stdio.h>

int main(void) {
    unsigned int a = 12;   /* 1100 בבינארי */
    unsigned int b = 10;   /* 1010 */

    printf("a & b  = %u\n", a & b);    /* 8: 1000, AND */
    printf("a | b  = %u\n", a | b);    /* 14: 1110, OR  */
    printf("a ^ b  = %u\n", a ^ b);    /* 6: 0110, XOR */
    printf("~a     = %u\n", ~a);       /* NOT: הופך כל ביט */
    printf("a << 2 = %u\n", a << 2);   /* 48: הזזה למעלה, כפל ב-4 */
    printf("a >> 2 = %u\n", a >> 2);   /* 3: הזזה למטה, חילוק ב-4 */
    return 0;
}

משתמשים בהם לדגלים, למסכות ולרגיסטרים של חומרה. שתי אזהרות: & ו-| הם לא && ו-|| (הם לא מבצעים short-circuit והם פועלים ביט אחרי ביט), והזזה של ערך עם סימן או הזזה ביותר מהרוחב של הטיפוס היא לא מוגדרת. השתמשו בטיפוסים בלי סימן לעבודה עם ביטים.

סדר קדימויות

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

ההשלכות המעשיות:

a + b * c       /* פירושו a + (b * c) */
a < b == c < d  /* פירושו (a < b) == (c < d): כמעט אף פעם לא מה שהתכוונתם */
x & 1 == 0      /* פירושו x & (1 == 0), כלומר x & 0: באג קלאסי */
*p++            /* פירושו *(p++): dereference ל-p, ואז קידום שלו */

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

אף אחד לא זוכר את כל חמש עשרה הרמות, ואף אחד לא צריך. למדו ש-* גובר על +, שהשוואות גוברות על && שגובר על ||, ושכל השאר מקבל סוגריים:

if ((flags & MASK) != 0 && (count > 0 || force)) { ... }

בשורה הזו יש סוגריים מיותרים, והיא טובה יותר בזכותם.