המרת טיפוסים ב-C: המרות מובלעות ו-Cast מפורש

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

המרה מובלעת

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

#include <stdio.h>

int main(void) {
    int    i = 5;
    double d = i;        /* int -> double: 5.0, מדויק */
    char   c = 'A';
    int    code = c;     /* char -> int: 65 */
    double pi = 3.9;
    int    truncated = pi;   /* double -> int: 3, ה-.9 נעלם */

    printf("d         = %f\n", d);
    printf("code      = %d\n", code);
    printf("truncated = %d\n", truncated);
    return 0;
}

המרות שלא יכולות לאבד מידע (int ל-double, char ל-int, short ל-long) הן המרות מרחיבות ותמיד בטוחות. המרות בכיוון ההפוך הן מצמצמות ועלולות לאבד נתונים: ה-3.9 שלמעלה הפך ל-3 בלי אזהרה, אלא אם תבקשו אחת עם -Wconversion.

ההמרות האריתמטיות הרגילות

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

1. כל דבר קטן מ-int (char, short, _Bool) מקודם ל-int. זה קידום מספרים שלמים (integer promotion), והוא קורה ראשון, תמיד.
2. אם אחד הצדדים הוא long double, השני הופך ל-long double.
3. אחרת, אם אחד מהם double, השני הופך ל-double.
4. אחרת, אם אחד מהם float, השני הופך ל-float.
5. אחרת, בין טיפוסים שלמים, זה עם הדרגה הגבוהה יותר מנצח, ואם הדרגות שוות, unsigned מנצח.

הכלל האחרון הוא זה שגורם לבאגים אמיתיים. השאר אינטואיטיביים.

#include <stdio.h>

int main(void) {
    char a = 100, b = 100;

    /* a ו-b מקודמים קודם ל-int, ולכן 10000 נכנס בלי בעיה. */
    printf("a * b as int = %d\n", a * b);

    /* אבל שמירה בחזרה ב-char מצמצמת אותו שוב. */
    char product = a * b;
    printf("stored in char = %d\n", product);
    return 0;
}

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

Cast מפורש

cast הוא טיפוס היעד בתוך סוגריים:

(double)x
(int)3.9
(char)65
(unsigned int)n

הוא חל על הביטוי שבא מיד אחריו, והוא נקשר חזק מאוד: חזק יותר מ-*, / או +.

#include <stdio.h>

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

    printf("no cast:        %f\n", (double)(total / count));  /* 3.0 */
    printf("cast first:     %f\n", (double)total / count);    /* 3.5 */
    printf("cast both:      %f\n", (double)total / (double)count);
    return 0;
}

השורה הראשונה מחלקת כמספרים שלמים (ומקבלת 3) ואז ממירה את 3 ל-3.0, מאוחר מדי. השנייה ממירה את total לדיוק שמאפשר 3.5 לפני החילוק, כך שהאופרטור / רואה double ו-int, מקדם את ה-int ומבצע חילוק עשרוני.

מספיק לעשות cast לאופרנד אחד. ההמרות האריתמטיות הרגילות מטפלות בשני.

תיקון חילוק של מספרים שלמים

זו הסיבה הנפוצה ביותר לכתוב cast ב-C:

#include <stdio.h>

int main(void) {
    int scores[] = {88, 92, 75, 61, 90};
    int n = 5;
    int sum = 0;

    for (int i = 0; i < n; i++) {
        sum += scores[i];
    }

    printf("sum = %d\n", sum);
    printf("wrong average: %f\n", (double)(sum / n));    /* 81.000000: חולק כמספרים שלמים, ורק אז הומר */
    printf("right average: %f\n", (double)sum / n);      /* 81.200000 */

    /* לאחוזים יש אותה מלכודת. */
    int passed = 3;
    printf("wrong pct: %d%%\n", passed / n * 100);            /* 0 אחוז */
    printf("right pct: %.1f%%\n", 100.0 * passed / n);        /* 60.0 אחוז */
    return 0;
}

שורת האחוזים מלמדת: passed / n הוא 3 / 5, שזה 0 במספרים שלמים, ו-0 * 100 הוא 0. כפל לפני החילוק (100 * passed / n) מתקן את זה גם בלי cast, כי 300 / 5 מדויק, אבל זה עובד רק כשהמספרים משתפים פעולה. ה-cast הוא התיקון האמין.

קטיעה, לא עיגול

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

#include <stdio.h>
#include <math.h>

int main(void) {
    printf("(int) 3.2  = %d\n", (int) 3.2);
    printf("(int) 3.9  = %d\n", (int) 3.9);    /* 3, לא 4 */
    printf("(int)-3.9  = %d\n", (int)-3.9);    /* -3, לא -4 */

    /* עיגול אמיתי מתוך math.h: */
    printf("round(3.9)  = %d\n", (int)round(3.9));    /* 4  */
    printf("round(-3.9) = %d\n", (int)round(-3.9));   /* -4 */
    printf("floor(3.9)  = %d\n", (int)floor(3.9));    /* 3  */
    printf("ceil(3.2)   = %d\n", (int)ceil(3.2));     /* 4  */
    return 0;
}

אם אתם בונים את זה על המכונה שלכם, זכרו ש-math.h צריך -lm בזמן הקישור ב-Linux.

סכנה נוספת: המרה של ערך עשרוני גדול מדי לטיפוס השלם היא undefined behavior, ולא גלגול. (int)1e20 יכול להפיק כל דבר. בדקו את הטווח לפני ה-cast כשהערך אינו בשליטתכם.

char ו-int

char ב-C הוא מספר שלם קטן שמחזיק קוד של תו. המרה בין השניים היא עבודה יומיומית:

#include <stdio.h>

int main(void) {
    char letter = 'A';
    int code = letter;

    printf("'%c' has code %d\n", letter, code);
    printf("code + 1 is '%c'\n", (char)(code + 1));   /* 'B' */

    /* מתו של ספרה לערך המספרי שלו: */
    char digit = '7';
    int value = digit - '0';
    printf("the character '%c' as a number is %d\n", digit, value);

    /* מאות גדולה לקטנה, בעזרת הפער הקבוע של 32 מקומות ב-ASCII: */
    for (char ch = 'A'; ch <= 'E'; ch++) {
        printf("%c -> %c\n", ch, (char)(ch + 32));
    }
    return 0;
}

digit - '0' הוא הניב הסטנדרטי להפיכת תו של ספרה לערך שלה, והוא עובד כי מובטח שעשרת תווי הספרות רציפים. עבור אותיות, העדיפו את toupper() ו-tolower() מתוך ctype.h על פני החשבון עם + 32: ההיסט הוא עובדה של ASCII, לא הבטחה של C.

מלכודת קשורה: פונקציות ב-ctype.h כמו isdigit ו-toupper מקבלות int שחייב להיות EOF או ערך שאפשר לייצג כ-unsigned char. העברה של char רגיל שהוא שלילי (אפשרי, כי char רגיל עשוי להיות signed) היא undefined. עשו cast: isdigit((unsigned char)c).

מלכודת signed/unsigned

שלב 5 בסולם ההמרות, unsigned מנצח בשוויון, מייצר את ההשוואה המפתיעה ביותר של C:

#include <stdio.h>

int main(void) {
    int          signed_val = -1;
    unsigned int unsigned_val = 1;

    if (signed_val < unsigned_val) {
        printf("-1 is less than 1  (what you expect)\n");
    } else {
        printf("-1 is NOT less than 1  (what C actually says)\n");
    }

    printf("(unsigned)-1 = %u\n", (unsigned int)signed_val);
    return 0;
}

-1 מומר ל-unsigned int, שמפרש מחדש את תבנית הביטים שלו כ-4,294,967,295. זה גדול מ-1, ולכן ההשוואה היא false.

אותה המרה גורמת ללולאות לרוץ לנצח:

/* באג: i הוא unsigned, ולכן i >= 0 תמיד אמת. כש-i הוא 0, i-- מתגלגל. */
for (size_t i = n - 1; i >= 0; i--) { ... }

והיא גורמת לבדיקות אורך להיכשל:

/* באג: strlen מחזירה size_t (unsigned). אם המחרוזת קצרה
   מ-5, len - 5 מתגלגל למספר ענק והבדיקה עוברת. */
if (strlen(s) - 5 > 0) { ... }

כתבו מחדש כ-if (strlen(s) > 5), והחיסור לא קורה אף פעם.

ההגנות: שמרו ספירות ואינדקסים בסוג סימן אחד לכל האורך, קמפלו עם -Wsign-compare (שכלול ב--Wextra), וכשאתם חייבים לערבב, עשו cast מפורש אחרי שווידאתם שהערך לא יכול להיות שלילי.

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

int main(void) {
    const char *s = "hi";
    size_t len = strlen(s);

    /* בטוח: השוואה בלי חיסור. */
    if (len > 5) {
        printf("long\n");
    } else {
        printf("short: %zu characters\n", len);
    }

    /* בטוח: cast לטיפוס עם סימן אחרי שידוע שהערך קטן. */
    int signed_len = (int)len;
    printf("len - 5 = %d\n", signed_len - 5);
    return 0;
}

Cast של מצביעים

casts ממירים גם בין טיפוסי מצביעים, וכאן יש בהם סיכון אמיתי, כי הם משנים את האופן שבו הזיכרון מתפרש, לא את הבתים עצמם.

#include <stdio.h>

int main(void) {
    int value = 1;
    /* צפייה בבתים של int דרך מצביע char. */
    unsigned char *bytes = (unsigned char *)&value;

    printf("int 1 is stored as bytes:");
    for (size_t i = 0; i < sizeof(int); i++) {
        printf(" %02x", bytes[i]);
    }
    printf("\n");
    return 0;
}

במכונת little-endian זה מדפיס 01 00 00 00. בדיקה של ייצוג האובייקט דרך unsigned char * היא אחד מה-casts המעטים של מצביעים שהתקן מאשר במפורש.

רוב ה-casts האחרים של מצביעים לא מאושרים. קריאה של int דרך float * מפרה את כלל ה-strict aliasing והיא undefined behavior, למרות שהיא מתקמפלת. כדי לפרש בתים מחדש, השתמשו ב-memcpy.

שתי מוסכמות ששווה להכיר. void * מומר אל כל טיפוס של מצביע לאובייקט וממנו בלי cast ב-C, ולכן לא כדאי לעשות cast לתוצאה של malloc:

int *arr = malloc(n * sizeof *arr);        /* C נכונה */
int *arr = (int *)malloc(n * sizeof *arr); /* מיותר, ומסתיר header חסר */

ה-cast נדרש ב-C++, ולכן הוא מופיע בכל כך הרבה קוד. ב-C הוא יכול להסתיר את הטעות של שכחת <stdlib.h>.

ו-printf("%p", ...) מצפה ל-void *, כך שארגומנטים של מצביעים שם באמת צריכים cast: printf("%p", (void *)p).

כש-cast הוא התשובה הלא נכונה

cast משתיק את הקומפיילר. לפעמים הקומפיילר צדק.

long big = 5000000000L;
int  small = (int)big;    /* ה-cast מסתיר איבוד נתונים אמיתי */

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