טיפוסי נתונים ב-C: int, float, char, double ועוד

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

רשימת הטיפוסים של C קצרה. המורכבות נמצאת במגדירים.

ארבעת טיפוסי הבסיס

#include <stdio.h>

int main(void) {
    char  initial = 'K';        /* one character / one byte */
    int   count   = 42;         /* whole number */
    float ratio   = 3.14f;      /* decimal, single precision */
    double precise = 3.141592653589793;  /* decimal, double precision */

    printf("char:   %c\n", initial);
    printf("int:    %d\n", count);
    printf("float:  %f\n", ratio);
    printf("double: %.15f\n", precise);
    return 0;
}

• char מחזיק בית אחד. משתמשים בו לתווים בודדים ('A'), לבתים של מחרוזת, ולפעמים כמספר שלם זעיר.
• int הוא סוס העבודה של המספרים השלמים. מוני לולאות, גדלים, מזהים.
• float ו-double מחזיקים מספרים ממשיים. ל-double יש בערך פי שניים דיוק.
• void הוא במובן מסוים הטיפוס הרביעי, אבל פירושו "אין ערך": אי אפשר להצהיר על משתנה void, רק להשתמש בו כטיפוס החזרה של פונקציה, כרשימת פרמטרים ריקה או כמצביע בלי טיפוס.

שימו לב לסיומת f ב-3.14f. בלעדיה הערך המילולי הוא double, והשמתו ל-float מאבדת דיוק בשקט. חלק מהקומפיילרים מזהירים על זה.

מגדירים: short, long, unsigned

טיפוסי השלמים הבסיסיים מגיעים עם מגדירים שמשנים את הגודל או את הסימן.

#include <stdio.h>

int main(void) {
    short small = 32000;
    int normal = 2000000;
    long big = 2000000000L;
    long long huge = 9000000000000000000LL;

    unsigned int positive_only = 4000000000U;

    printf("short:        %hd\n", small);
    printf("int:          %d\n", normal);
    printf("long:         %ld\n", big);
    printf("long long:    %lld\n", huge);
    printf("unsigned int: %u\n", positive_only);
    return 0;
}

כל טיפוס שלם צריך מציין פורמט משלו: %hd ל-short, %d ל-int, %ld ל-long, %lld ל-long long, %u ל-unsigned. שימוש במציין הלא נכון הוא התנהגות לא מוגדרת, לא שגיאת עיגול.

unsigned מסיר את ביט הסימן ומכפיל את הטווח החיובי. unsigned int מחזיק 0 עד בערך 4.3 מיליארד במקום ממינוס 2.1 עד פלוס 2.1 מיליארד. זו הבחירה הנכונה לדברים שבאמת לא יכולים להיות שליליים, גדלים, ספירות של בתים, תבניות ביטים, ומלכודת לכל דבר שעלול לרדת מתחת לאפס בחיסור.

signed היא ברירת המחדל עבור int, short, long ו-long long, כך שכמעט אף פעם לא כותבים אותה. המקום היחיד שבו זה משנה הוא char: האם char רגיל הוא עם סימן או בלי תלוי מימוש, אז כתבו signed char או unsigned char כשהסימן משנה.

גדלים: מה מקבלים בפועל

תקן C מגדיר מינימום, לא גדלים מדויקים. בכל מכונת Linux, macOS או Windows מודרנית של 64 ביט תראו את זה:

שורת ה-long היא זו שתופסת אנשים: היא 8 בתים ב-Linux וב-macOS, ו-4 בתים ב-Windows של 64 ביט. קוד שמניח ש-long יכול להחזיק ערך של 64 ביט אינו נייד. השתמשו ב-long long, או בטיפוסים ברוחב מדויק מ-stdint.h (int32_t, uint64_t) כשהגודל הוא חלק מהדרישה.

sizeof: שאלו את הקומפיילר

לעולם אל תנחשו גודל, מדדו אותו:

#include <stdio.h>

int main(void) {
    printf("char:        %zu byte(s)\n", sizeof(char));
    printf("short:       %zu bytes\n", sizeof(short));
    printf("int:         %zu bytes\n", sizeof(int));
    printf("long:        %zu bytes\n", sizeof(long));
    printf("long long:   %zu bytes\n", sizeof(long long));
    printf("float:       %zu bytes\n", sizeof(float));
    printf("double:      %zu bytes\n", sizeof(double));
    printf("a pointer:   %zu bytes\n", sizeof(int *));
    return 0;
}

sizeof הוא אופרטור, לא פונקציה, והוא מחושב בזמן קומפילציה. הוא מחזיר ערך מטיפוס size_t, שמודפס עם %zu.

sizeof(char) מובטח להיות בדיוק 1: זו ההגדרה של בית ב-C. כל השאר נמדד ביחס אליו.

limits.h ו-float.h

הטווחים המדויקים של הקומפיילר שלכם זמינים כקבועים עם שמות:

#include <stdio.h>
#include <limits.h>
#include <float.h>

int main(void) {
    printf("INT_MIN      = %d\n", INT_MIN);
    printf("INT_MAX      = %d\n", INT_MAX);
    printf("UINT_MAX     = %u\n", UINT_MAX);
    printf("LONG_MAX     = %ld\n", LONG_MAX);
    printf("CHAR_BIT     = %d bits per byte\n", CHAR_BIT);
    printf("FLT_DIG      = %d decimal digits\n", FLT_DIG);
    printf("DBL_DIG      = %d decimal digits\n", DBL_DIG);
    return 0;
}

אלה הערכים שמולם משווים כשצריך לדעת אם פעולה תגלוש. בדיקת if (a > INT_MAX - b) לפני חישוב a + b היא הדרך לזהות גלישה לפני שהיא קורית, וזה חשוב, כי אי אפשר לזהות גלישה של ערך עם סימן אחרי המעשה.

גלישת מספרים שלמים

מה שקורה כשערך חורג מהטווח של הטיפוס שלו תלוי לגמרי בסימן.

גלישה של ערך בלי סימן מוגדרת: הערך מתגלגל מודולו 2^N.

#include <stdio.h>
#include <limits.h>

int main(void) {
    unsigned int u = UINT_MAX;
    printf("UINT_MAX     = %u\n", u);
    printf("UINT_MAX + 1 = %u\n", u + 1);   /* guaranteed to be 0 */

    unsigned int zero = 0;
    printf("0 - 1        = %u\n", zero - 1); /* wraps to UINT_MAX */
    return 0;
}

המקרה השני הוא מקור אמיתי לבאגים. לולאה כמו for (unsigned i = n - 1; i >= 0; i--) לעולם לא נגמרת, כי ערך בלי סימן הוא תמיד >= 0.

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

int sum = a + b;
if (sum < a) { /* the compiler may remove this entirely */ }

בדקו לפני, בעזרת הגבולות:

if (b > 0 && a > INT_MAX - b) {
    /* a + b would overflow - handle it */
}

דיוק של נקודה צפה

float ו-double מאחסנים מספרים בבינארי, ולרוב השברים העשרוניים אין צורה בינארית מדויקת, בדיוק כמו של-1/3 אין צורה עשרונית מדויקת.

#include <stdio.h>

int main(void) {
    double a = 0.1;
    double b = 0.2;
    double sum = a + b;

    printf("0.1 + 0.2 = %.20f\n", sum);
    printf("Is it 0.3? %s\n", (sum == 0.3) ? "yes" : "no");

    /* The right way: compare within a tolerance. */
    double diff = sum - 0.3;
    if (diff < 0) diff = -diff;
    printf("Close enough? %s\n", (diff < 1e-9) ? "yes" : "no");
    return 0;
}

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

ולעולם אל תשתמשו בנקודה צפה לכסף. אחסנו אגורות כמספר שלם; long long של אגורות מדויק, בעוד ש-double של שקלים לא.

בחירת טיפוס

רשימת החלטות קצרה שמכסה את רוב הקוד:

• מספרים שלמים: int, אלא אם יש לכם סיבה. זה הטיפוס שהמעבד מטפל בו ביעילות הגבוהה ביותר, והטיפוס שכל כללי החשבון בנויים סביבו.
• כל דבר גדול מ-2 מיליארד: long long, או int64_t מ-stdint.h.
• גדלים, אורכים ואינדקסים של מערכים מ-sizeof או מ-strlen: size_t. הוא בלי סימן ומובטח להיות גדול מספיק לכל אובייקט.
• מספרים עשרוניים: double. השתמשו ב-float רק כדי לחצות את הזיכרון במערכים גדולים או בחומרה משובצת בלי יחידה לדיוק כפול.
• תווים בודדים ובתים גולמיים: char לטקסט, unsigned char לנתונים בינאריים.
• אמת/שקר: bool מ-stdbool.h; ראו ערכים בוליאניים ב-C.
• רוחב ביטים מדויק (פורמטים של קבצים, פרוטוקולי רשת, רגיסטרים של חומרה): stdint.h, כלומר uint8_t, int16_t, uint32_t וכן הלאה.

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

int main(void) {
    uint8_t  flags = 0xFF;          /* exactly 8 bits, unsigned */
    int32_t  offset = -100000;      /* exactly 32 bits, signed */
    uint64_t file_size = 5000000000ULL;

    printf("flags:     %u\n", flags);
    printf("offset:    %d\n", offset);
    printf("file_size: %llu bytes\n", (unsigned long long)file_size);
    return 0;
}

ערבוב טיפוסים

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

#include <stdio.h>

int main(void) {
    int a = 7, b = 2;

    printf("7 / 2  as ints   = %d\n", a / b);        /* 3, not 3.5 */
    printf("7 / 2  with 2.0  = %f\n", a / 2.0);      /* 3.5 */

    int  small = -1;
    unsigned int big = 1;
    printf("-1 < 1u ? %s\n", (small < big) ? "yes" : "no");  /* surprising */
    return 0;
}

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

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