printf ב-C: מחרוזות פורמט, specifiers והדפסת מספרים עשרוניים

printf היא הפונקציה הראשונה שכל מתכנת C לומד, וזו שרובם אף פעם לא קראו את התיעוד שלה עד הסוף. שווה להקדיש לה עשר דקות, כי מחרוזת הפורמט שלה היא שפה קטנה בפני עצמה, וכי specifier שגוי הוא לא סתם שגיאת הקלדה, הוא undefined behavior.

היא נמצאת ב-<stdio.h>, ולכן כל תוכנית שמשתמשת בה מתחילה ב-#include <stdio.h>.

המודל של מחרוזת הפורמט

printf עוברת על מחרוזת הפורמט תו אחר תו. כל מה שאינו % מודפס בדיוק כפי שנכתב. % פותח conversion specification, שצורך את הארגומנט הבא ומדפיס אותו בצורה המבוקשת.

#include <stdio.h>

int main(void) {
    int    count = 5;
    double price = 2.5;
    char   grade = 'A';
    const char *name = "apples";

    printf("Plain text, no arguments.\n");
    printf("%d %s cost $%.2f (grade %c)\n", count, name, price, grade);
    return 0;
}

הארגומנטים מותאמים ל-specifiers אך ורק לפי המיקום: ה-% הראשון לוקח את count, השני לוקח את name, וכן הלאה. ל-printf אין שום דרך לבדוק שהעברתם את מה שהבטחתם, כי היא לא רואה את הטיפוסים, ולכן מחרוזת הפורמט היא חוזה שאתם חייבים לכבד. בגלל זה כדאי להפעיל את -Wall: GCC קורא את מחרוזת הפורמט הליטרלית בזמן הקומפילציה ומזהיר כשארגומנט לא מתאים.

שום דבר לא מכריח ירידת שורה. printf("Hello") משאירה את הסמן אחרי ה-o, ולכן כמעט כל מחרוזת פורמט מסתיימת ב-\n.

ה-specifiers שמשתמשים בהם כל יום

חמישה מכסים את רוב הקוד:

#include <stdio.h>

int main(void) {
    int x = 42;

    printf("int     : %d\n", x);
    printf("double  : %f\n", 2.5);
    printf("string  : %s\n", "hello");
    printf("char    : %c\n", 'A');
    printf("pointer : %p\n", (void *)&x);
    printf("percent : 100%%\n");
    return 0;
}

בקטע הזה מסתתרים שני כללים. % ליטרלי כותבים כ-%%: % בודד בסוף מחרוזת פורמט הוא undefined behavior. ו-%p דורש void *, לכן בצעו cast למצביע. העברה ישירה של int * היא מבחינה טכנית undefined, גם אם בפועל היא מודפסת בסדר.

הטבלה המלאה, עם כל specifier, כל length modifier ועמודת ה-scanf, נמצאת בעמוד format specifiers. העמוד הזה נשאר עם אלה שבאמת משתמשים בהם.

רוחב, דיוק ויישור

בין ה-% לבין האות אפשר לשים דגלים, רוחב ודיוק. כך הופכים לולאה לטבלה.

#include <stdio.h>

int main(void) {
    printf("|%5d|\n", 42);        /* רוחב 5, ריפוד לפני הערך */
    printf("|%-5d|\n", 42);       /* דגל מינוס: ריפוד אחרי הערך   */
    printf("|%05d|\n", 42);       /* דגל אפס: ריפוד באפסים         */
    printf("|%+d|\n", 42);        /* דגל פלוס: תמיד להציג את הסימן   */
    printf("|%8.2f|\n", 3.14159); /* רוחב 8, 2 ספרות אחרי הנקודה */
    printf("|%-10s|\n", "ok");    /* גם מחרוזות מרופדות                   */
    printf("|%.3s|\n", "truncate me");  /* דיוק על מחרוזת חותך אותה */
    return 0;
}

הרוחב הוא מינימום, אף פעם לא מקסימום: %3d עם הערך 123456 מדפיס את כל שש הספרות. לדיוק יש משמעות שונה לכל טיפוס: ספרות אחרי הנקודה העשרונית עבור %f, מספר תווים מקסימלי עבור %s, ומספר ספרות מינימלי עבור %d.

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

#include <stdio.h>

int main(void) {
    const char *names[] = {"Ada", "Grace", "Alan"};
    double scores[] = {92.5, 105.25, 87.0};
    int width = 10;

    printf("%-*s %8s\n", width, "NAME", "SCORE");
    for (int i = 0; i < 3; i++) {
        printf("%-*s %8.2f\n", width, names[i], scores[i]);
    }
    return 0;
}

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

הדפסה הגיונית של מספרים עשרוניים

%f בלי דיוק תמיד מדפיס שש ספרות אחרי הנקודה, ולעיתים רחוקות זה מה שמישהו רוצה:

#include <stdio.h>

int main(void) {
    double value = 1234.5;
    double tiny  = 0.000012345;
    double huge  = 123456789012.0;

    printf("%%f    : %f\n", value);
    printf("%%.2f  : %.2f\n", value);
    printf("%%.0f  : %.0f\n", value);
    printf("%%e    : %e\n", tiny);
    printf("%%g    : %g\n", tiny);
    printf("%%g    : %g\n", huge);
    printf("%%g    : %g\n", value);
    return 0;
}

שלוש אפשרויות, וכלל אצבע לכל אחת:

• %.Nf לכסף, למדידות ולכל דבר עם מספר טבעי של ספרות עשרוניות. %.2f הוא מה שתרצו עבור מטבע.
• %e לכתיב מדעי, תמיד בצורה d.dddddde±dd.
• %g כשלא יודעים מראש את סדר הגודל. הוא בוחר בין %f ל-%e, לפי מה שקצר יותר, ומוריד אפסים בסוף. זו ברירת המחדל השפויה ביותר לרישום ערך שעוד לא ראיתם.

מלכודת אחת שכדאי לומר במפורש: אין %lf ב-printf. ארגומנטים מסוג float מקודמים ל-double עוד לפני ש-printf רואה אותם, ולכן %f מטפל בשניהם, ו-%lf בעל משמעות רק ב-scanf, שם הגודל של היעד חשוב. (C99 אכן מקבל %lf ב-printf כמילה נרדפת, אבל ההרגל לכתוב אותו גורם לאנשים לכתוב %f ב-scanf, ושם זה באמת נשבר.)

מספרים שלמים ברוחבים אחרים

%d מיועד ל-int. טיפוסים גדולים יותר או unsigned צריכים length modifier, ואי התאמה ביניהם היא undefined behavior ולא שגיאת עיגול:

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

int main(void) {
    long           big  = 3000000000L;
    unsigned int   u    = 4000000000u;
    size_t         len  = sizeof "hello";
    uint64_t       id   = 1234567890123456789ULL;

    printf("long     : %ld\n", big);
    printf("unsigned : %u\n", u);
    printf("size_t   : %zu\n", len);
    printf("uint64_t : %llu\n", (unsigned long long)id);

    printf("hex      : %x  HEX: %X  octal: %o\n", 255, 255, 8);
    return 0;
}

%zu עבור size_t הוא זה שאנשים טועים בו הכי הרבה: sizeof מחזיר size_t, לא int, ולכן printf("%d", sizeof x) הוא באג שבמקרה עובד במערכות 32 ביט ומתנהג לא נכון במערכות 64 ביט.

הערך המוחזר

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

#include <stdio.h>

int main(void) {
    int written = printf("Hello, world!\n");
    printf("that call wrote %d characters\n", written);

    /* שימושי לקו תחתון מתחת למשהו שהרוחב שלו לא ידוע: */
    const char *title = "Report";
    int n = printf("%s\n", title) - 1;   /* פחות ירידת השורה */
    for (int i = 0; i < n; i++) {
        putchar('=');
    }
    putchar('\n');
    return 0;
}

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

#include <stdio.h>

int main(void) {
    char buffer[32];
    int n = snprintf(buffer, sizeof buffer, "%s scored %.1f", "Ada", 92.5);

    printf("[%s] (%d chars wanted)\n", buffer, n);
    return 0;
}

snprintf מחזירה את האורך שהמחרוזת המלאה הייתה צריכה, ולכן ערך מוחזר ששווה לגודל ה-buffer או גדול ממנו מראה שהפלט נקטע.

פגיעות מחרוזת הפורמט

זו בעיית האבטחה היחידה ב-printf, והיא חמורה. לעולם אל תעבירו כמחרוזת הפורמט נתונים שלא אתם כתבתם:

/* מסוכן: לעולם אל תעשו את זה */
printf(user_input);

/* נכון */
printf("%s", user_input);

אם user_input מכיל %s, הפונקציה printf קוראת ארגומנט שמעולם לא הועבר והולכת אחרי כל זבל שנראה כמו מצביע שהיא מוצאת, ובדרך כלל קורסת. %x שחוזר על עצמו שופך את תוכן ה-stack למסך, ושם עלולים להיות סיסמאות או מפתחות. ו-%n, שכותב את מספר התווים לתוך ארגומנט, הפך את זה היסטורית להשחתת זיכרון שרירותית ולהרצת קוד מרחוק.

הכלל מוחלט ולא עולה כלום: מחרוזת הפורמט היא תמיד ליטרל שאתם כתבתם. כל דבר משתנה נכנס כארגומנט. -Wformat-security של GCC מסמן את הטעות, והוא כלול ב--Wall -Wextra.

Buffering: למה פלט מופיע לפעמים באיחור

printf לא כותבת לטרמינל מיד. הפלט עובר buffering: הוא נשפך כשה-buffer מתמלא, כשמופיעה ירידת שורה בטרמינל, או כשהתוכנית מסתיימת כרגיל. שתי השלכות:

• תוכנית שקורסת עלולה לאבד פלט ש"כבר הודפס". אם אתם מדבגים עם printf וההודעה האחרונה לא מופיעה אף פעם, הקריסה קרתה אחרי השורה הזו, לא לפניה. הוסיפו fflush(stdout) או שלחו את פלט הדיבוג ל-stderr, שאין לו buffer.
• fprintf(stderr, ...) היא הדרך הנכונה להדפיס שגיאות. היא בלי buffer, והיא הולכת ל-stream נפרד שמשתמשים יכולים להפנות בנפרד מהפלט הרגיל.

#include <stdio.h>

int main(void) {
    printf("normal output goes to stdout\n");
    fprintf(stderr, "errors go to stderr\n");
    fflush(stdout);
    return 0;
}