Format specifiers ב-C: המדריך המלא ל-printf ו-scanf

format specifier אומר ל-printf איך להפוך ערך לטקסט, ול-scanf איך להפוך טקסט לערך. זה החלק היחיד ב-C שבו הקומפיילר לא יכול לעזור לכם כברירת מחדל, כי טיפוסי הארגומנטים בלתי נראים לפונקציה, ולכן העמוד הזה הוא הטבלה שכדאי לבדוק מולה.

הצורה הכללית של מגדיר היא:

%[flags][width][.precision][length]conversion

רק ה-% ואות ההמרה הם חובה. %-8.2lf משתמש בכל חמשת החלקים.

טבלת ההמרות

#include <stdio.h>

int main(void) {
    int x = 255;

    printf("%%d  : %d\n", x);
    printf("%%u  : %u\n", x);
    printf("%%x  : %x\n", x);
    printf("%%X  : %X\n", x);
    printf("%%o  : %o\n", x);
    printf("%%c  : %c\n", 65);
    printf("%%s  : %s\n", "text");
    printf("%%f  : %f\n", 3.5);
    printf("%%e  : %e\n", 3.5);
    printf("%%g  : %g\n", 3.5);
    printf("%%p  : %p\n", (void *)&x);
    return 0;
}

שתי רשומות ראויות לאזהרה. %n כותב לזיכרון במקום להדפיס, והוא המנגנון שמאחורי פגיעות ה-format string: לעולם אל תתנו לטקסט של משתמש להגיע למחרוזת פורמט. ו-%p דורש void *; העברה ישירה של int * היא לא מוגדרת, למרות שכל קומפיילר אמיתי מדפיס את הכתובת בכל מקרה.

מגדירי אורך

מגדיר האורך בא בין הדיוק לאות ההמרה, והוא אומר מה הגודל האמיתי של הארגומנט.

המרות עם סימן (d i) ובלי סימן (u x o) מקבלות טיפוסים שונים: %lu מצפה ל-unsigned long, לא ל-long, וטעות בזה היא התנהגות לא מוגדרת, לא פספוס קוסמטי.

ועבור משפחות הנקודה הצפה והתווים:

הצירופים שבאמת תקלידו:

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

int main(void) {
    short              s   = -12;
    long               l   = 3000000000L;
    long long          ll  = 9000000000000000000LL;
    unsigned long      ul  = 4000000000UL;
    unsigned long long ull = 18000000000000000000ULL;
    size_t             len = strlen("hello");
    long double        ld  = 2.5L;

    printf("short              : %hd\n", s);
    printf("long               : %ld\n", l);
    printf("long long          : %lld\n", ll);
    printf("unsigned long      : %lu\n", ul);
    printf("unsigned long long : %llu\n", ull);
    printf("size_t             : %zu\n", len);
    printf("long double        : %Lf\n", ld);
    return 0;
}

את %zu כדאי לזכור בעל פה. sizeof, strlen וכל גודל בספרייה הסטנדרטית מחזירים size_t, שהוא 8 בתים במערכת של 64 ביט, בעוד ש-int הוא 4. printf("%d", strlen(s)) הוא באג אמיתי שנראה עובד בחלק מהפלטפורמות: השתמשו ב-%zu.

המגדירים hh ו-h קיימים בעיקר בשביל scanf, שבו הגודל של היעד חשוב. ב-printf, short מקודם ל-int לפני הקריאה, כך ש-%d היה מדפיס אותו נכון בכל מקרה; %hd רק מתעד את הכוונה.

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

עבור טיפוסים מ-<stdint.h> כמו int32_t, המגדירים הניידים הם מאקרו מ-<inttypes.h>:

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

int main(void) {
    int32_t  a = -2000000000;
    uint64_t b = 18000000000000000000ULL;

    printf("int32_t  : %" PRId32 "\n", a);
    printf("uint64_t : %" PRIu64 "\n", b);
    return 0;
}

PRId32 מתרחב לאותיות הנכונות עבור הפלטפורמה שלכם, ומחרוזות מילוליות צמודות מתחברות, ולכן הפורמט מפוצל לשלושה חלקים. זה מכוער; החלופה, המרה ל-long long ושימוש ב-%lld, לעתים קרובות קריאה יותר ותמיד נכונה.

דגלים

דגלים באים מיד אחרי ה-% ומשנים את התצוגה. הם חלים רק על printf.

#include <stdio.h>

int main(void) {
    printf("|%6d|\n",   42);
    printf("|%-6d|\n",  42);
    printf("|%06d|\n",  42);
    printf("|%+d|\n",   42);
    printf("|% d|\n",   42);
    printf("|%#x|\n",  255);
    printf("|%#o|\n",   64);
    printf("|%#.0f|\n", 3.0);
    return 0;
}

אפשר לשלב דגלים: %-+8.2f הוא רוחב מינימלי 8, שתי ספרות אחרי הנקודה, תמיד עם סימן, ריפוד אחרי המספר. - גובר על 0 אם כותבים את שניהם.

רוחב ודיוק

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

#include <stdio.h>

int main(void) {
    printf("|%10.3f|\n", 3.14159);     /* רוחב 10, 3 ספרות אחרי הנקודה */
    printf("|%.5d|\n",   42);          /* לפחות 5 ספרות     */
    printf("|%.3s|\n",   "abcdefg");   /* לכל היותר 3 תווים      */
    printf("|%.0f|\n",   2.71828);     /* בלי ספרות אחרי הנקודה          */
    printf("|%*d|\n",    8, 42);       /* רוחב מארגומנט */
    printf("|%.*f|\n",   3, 3.14159);  /* דיוק מארגומנט */
    return 0;
}

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

ב-scanf לרוחב יש תפקיד אחר וחשוב הרבה יותר: הוא מגביל כמה קלט ההמרה תצרוך, וזה הדבר היחיד שעומד בין %s לבין buffer overflow.

איפה printf ו-scanf שונים

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

#include <stdio.h>

int main(void) {
    double d;
    char   word[16];

    printf("Enter a decimal number and a word: ");
    if (scanf("%lf %15s", &d, word) == 2) {   /* %lf ורוחב */
        printf("%.3f and \"%s\"\n", d, word); /* %f ודיוק */
    } else {
        printf("Input did not match.\n");
    }
    return 0;
}

נסו 2.5 hello. הפורמט שקורא אותו והפורמט שמדפיס אותו משתמשים באותיות שונות עבור אותו double, וה-15 ב-%15s מגביל את הקלט ל-15 תווים ועוד תו הסיום, בדיוק הגודל של word.

ה-scanset של scanf

%[...] קורא קבוצה של תווים במקום מילה שמופרדת ברווחים. זו הדרך לקרוא שורה שלמה עם scanf, אם כי fgets נשאר הכלי הטוב יותר:

#include <stdio.h>

int main(void) {
    char line[64];

    printf("Type a sentence: ");
    if (scanf("%63[^\n]", line) == 1) {     /* הכול עד שורה חדשה */
        printf("You typed: %s\n", line);
    }
    return 0;
}

[^\n] פירושו "כל תו חוץ משורה חדשה". %[0-9] יקרא רק ספרות, %[abc] רק את שלוש האותיות האלה. בניגוד ל-%s, scanset לא מדלג על רווחים מובילים, כך ששורה חדשה תועה ב-buffer גורמת לו לא להתאים לכלום.

טעות היא התנהגות לא מוגדרת

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

printf("%d\n", 3.5);        /* מדפיס זבל: קורא את הביטים של double כ-int */
printf("%s\n", 42);         /* מתייחס ל-42 ככתובת: קריסה */
printf("%d\n", strlen(s));  /* size_t נקרא כ-int: שגוי ב-64 ביט */
printf("%f\n", 3);          /* int נקרא כ-double: זבל */

ההגנה עולה דגל אחד. קמפלו עם -Wall ו-GCC יבדוק כל מחרוזת פורמט מילולית מול הארגומנטים שלה:

gcc -Wall -Wextra program.c -o program

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

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