scanf ב-C: קליטת קלט, כלל ה-& ולמה זה מפסיק לעבוד

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

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

הצורה הבסיסית, ולמה &

#include <stdio.h>

int main(void) {
    int age;

    printf("Enter your age: ");
    scanf("%d", &age);

    printf("Next year you will be %d.\n", age + 1);
    return 0;
}

כדי להריץ את זה, הקלידו מספר ולחצו Enter. ה-&age הוא לא קישוט. C מעבירה כל ארגומנט by value, כך שאם הייתם כותבים scanf("%d", age) הפונקציה הייתה מקבלת עותק של הערך הנוכחי (הזבל) של age, בלי שום דרך להגיע למשתנה עצמו. &age מעביר את הכתובת של המשתנה, ו-scanf כותבת דרכה. בעמוד המצביעים תמצאו את התמונה המלאה.

השמטת ה-& היא הטעות הנפוצה ביותר עם scanf. הקומפיילר עם -Wall תופס אותה (format '%d' expects argument of type 'int *'), ובלי אזהרות מופעלות הקוד מתקמפל ומשחית זיכרון בכתובת אקראית כלשהי.

קריאה של כמה ערכים

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

#include <stdio.h>

int main(void) {
    int    day, month, year;

    printf("Enter a date as DD MM YYYY: ");
    if (scanf("%d %d %d", &day, &month, &year) != 3) {
        printf("That was not three numbers.\n");
        return 1;
    }

    printf("%04d-%02d-%02d\n", year, month, day);
    return 0;
}

הרווחים הליטרליים ב-"%d %d %d" בעצם מיותרים, כי %d כבר מדלג על רווחים בהתחלה, אבל הם הופכים את הפורמט לקריא. מה שלא מיותר הוא בדיקת הערך המוחזר, שמוסברת בהמשך.

תווים שאינם רווחים בפורמט חייבים להתאים לקלט בדיוק, וכך קוראים קלט מובנה:

#include <stdio.h>

int main(void) {
    int h, m;

    printf("Enter a time as HH:MM: ");
    if (scanf("%d:%d", &h, &m) == 2) {
        printf("%d hours and %d minutes\n", h, m);
    } else {
        printf("Could not parse that.\n");
    }
    return 0;
}

ה-: בפורמט דורש : בקלט. הקלידו 9:30 והניתוח מצליח, הקלידו 9 30 והוא נכשל אחרי קריאת ה-9.

תמיד בדקו את הערך המוחזר

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

#include <stdio.h>

int main(void) {
    int n;

    printf("Enter a number: ");
    int result = scanf("%d", &n);

    if (result == 1) {
        printf("Got %d\n", n);
    } else if (result == 0) {
        printf("That was not a number.\n");
    } else {
        printf("Input ended.\n");
    }
    return 0;
}

הקלידו hello בהנחיה. scanf מחזירה 0, n נשאר ללא שינוי, עדיין עם הזבל שהיה בו מההתחלה, והטקסט הבעייתי עדיין יושב ב-stream הקלט. החלק האחרון הזה הוא מה שהופך קלט שגוי אחד ללולאה אינסופית:

/* באג: מסתובבת לנצח על קלט שאינו מספרי */
while (scanf("%d", &n) != 1) {
    printf("Try again: ");
}

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

#include <stdio.h>

/* זורקת הכול עד ירידת השורה הבאה, כולל אותה. */
static void discard_line(void) {
    int c;
    while ((c = getchar()) != '\n' && c != EOF) {
        /* כלום */
    }
}

int main(void) {
    int n;
    int r;

    printf("Enter a number: ");
    while ((r = scanf("%d", &n)) != 1) {
        if (r == EOF) {
            printf("\nNo more input.\n");
            return 1;
        }
        discard_line();
        printf("Not a number. Try again: ");
    }

    printf("Got %d\n", n);
    return 0;
}

בדיקת ה-EOF חשובה: כש-stream הקלט נגמר (המשתמש לוחץ Ctrl+D, או שקובץ שהועבר בצינור נגמר), scanf מחזירה EOF מאז ולתמיד, כך שלולאה שבודקת רק != 1 מנסה שוב לנצח. טפלו ב"קלט שגוי" וב"אין יותר קלט" כשני המקרים השונים שהם. כשזה במקום, כדאי לשמור את פונקציית העזר discard_line בכל תוכנית שמשתמשת ב-scanf על קלט של בני אדם.

גלישת ה-buffer של %s

%s קורא תווים לתוך מערך של char. שימו לב שאין &: שם של מערך כבר מתדרדר למצביע לאיבר הראשון שלו, ולכן &name היה מהטיפוס הלא נכון.

הבעיה היא ש-%s רגיל לא יודע מה גודל המערך שלכם:

char name[10];
scanf("%s", name);      /* מסוכן: מקלידים 40 תווים, נכתבים 41 בתים */

שום דבר לא עוצר את הכתיבה בסוף המערך. היא ממשיכה לכל מה שנמצא אחריו בזיכרון, משתנים אחרים, כתובת החזרה, וזו גלישת ה-buffer הקלאסית, ומבחינה היסטורית סוג הבאגים המנוצל ביותר ב-C. הפתרון הוא רוחב בין ה-% ל-s, קטן באחד מגודל המערך כדי להשאיר מקום ל-'\0' שמסיים את המחרוזת:

#include <stdio.h>

int main(void) {
    char name[20];

    printf("Enter your first name: ");
    if (scanf("%19s", name) == 1) {     /* 19 תווים + '\0' = 20 */
        printf("Hello, %s!\n", name);
    }
    return 0;
}

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

ההפתעה השנייה של %s: הוא נעצר ברווח הראשון. הקלידו Ada Lovelace, ו-name יכיל Ada, בזמן ש-Lovelace מחכה ב-stream לקריאה הבאה. %s קורא מילה, לא שורה.

באג ירידת השורה שנשארת

זה ה-"scanf not working" שכולם נתקלים בו. specifiers מספריים מדלגים על רווחים בהתחלה, %c לא.

#include <stdio.h>

int main(void) {
    int age;
    char initial;

    printf("Enter your age: ");
    scanf("%d", &age);

    printf("Enter your initial: ");
    scanf(" %c", &initial);      /* הרווח בהתחלה הוא כל התיקון */

    printf("%c is %d years old.\n", initial, age);
    return 0;
}

הנה מה שקורה בלי הרווח הזה. אתם מקלידים 30 ולוחצים Enter. %d צורך את ה-3 ואת ה-0 ונעצר בירידת השורה, ומשאיר '\n' ב-buffer. הקריאה הבאה, scanf("%c", &initial), קוראת את ירידת השורה הזו כתו וחוזרת מיד: ההנחיה מופיעה ומדולגת באותה נשימה.

רווח במחרוזת הפורמט של scanf פירושו "דלג כאן על כל כמות של רווחים לבנים", ולכן " %c" עובר מעל ירידת השורה התועה ומחכה לתו אמיתי. הרווח נחוץ רק לפני %c ו-%[, וכל specifier אחר מדלג על רווחים לבד.

קריאת float ו-char

ה-specifiers ברובם משותפים עם printf, עם הבדל חשוב אחד: scanf צריכה לדעת את הגודל המדויק של היעד, כי היא כותבת דרך מצביע.

#include <stdio.h>

int main(void) {
    float  f;
    double d;
    int    i;
    char   c;

    printf("Enter a float, a double, an int and a char: ");
    if (scanf("%f %lf %d %c", &f, &d, &i, &c) == 4) {
        printf("%.2f %.4f %d %c\n", f, d, i, c);
    } else {
        printf("Input did not match.\n");
    }
    return 0;
}

נסו 1.5 2.25 7 x.

%f קורא float, ו-%lf קורא double. ב-printf שניהם מודפסים באותה דרך, כי float מקודם ל-double לפני הקריאה, אבל ב-scanf אין קידום, ושימוש ב-%f עם double * כותב ארבעה בתים לתוך משתנה של שמונה בתים ומשאיר אותו פגום. ה-%c כאן לא צריך רווח לפניו, כי ה-%d שלפניו כבר נעצר ברווח ולא בירידת שורה. (הטבלה המלאה בעמוד format specifiers.)

fgets: החלופה החסינה

לכל דבר שאדם מקליד, קראו את השורה כולה ונתחו אותה אחר כך. fgets מקבלת את גודל ה-buffer כארגומנט, ולכן היא פיזית לא יכולה לגלוש, וכשהשורה נכנסת היא צורכת גם את ירידת השורה, כך ששום דבר לא נשאר מאחור כדי לבלבל את הקריאה הבאה. (שורה ארוכה מה-buffer משאירה את הזנב שלה לא נקרא: ה-'\n' החסר במה שקיבלתם הוא הדרך לזהות את זה.)

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

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

    printf("Enter your full name: ");
    if (fgets(line, sizeof line, stdin) == NULL) {
        return 1;
    }
    line[strcspn(line, "\n")] = '\0';     /* חיתוך ירידת השורה ש-fgets שומרת */
    printf("Hello, %s!\n", line);

    printf("Enter your age: ");
    if (fgets(line, sizeof line, stdin) == NULL) {
        return 1;
    }
    int age = (int)strtol(line, NULL, 10);
    printf("Next year: %d\n", age + 1);
    return 0;
}

שלוש נקודות לגבי הדפוס הזה:

• sizeof line מעביר את הגודל האמיתי, כך ששינוי גודל המערך לא דורש שום עריכה נוספת, בניגוד לליטרל %19s.
• fgets שומרת את ירידת השורה אם השורה נכנסה, ובגלל זה יש את החיתוך עם strcspn. כך גם מזהים שורה ארוכה מדי ל-buffer: אין '\n' במה שקיבלתם.
• נתחו אחר כך. strtol למספרים שלמים (היא גם יכולה לספר לכם איפה הניתוח נעצר), strtod למספרים עשרוניים, או sscanf(line, "%d %d", &a, &b) כדי להשתמש בפורמט של scanf על מחרוזת שכבר מחזיקים בצורה בטוחה.

sscanf ראויה לאזכור משלה: זו scanf שקוראת ממחרוזת במקום מ-stream הקלט, והיא משתלבת מושלם עם fgets. מקבלים את הניתוח הנוח של scanf בלי אף אחת מבעיות ה-stream שלה.

טעויות נפוצות

• שכחת & בארגומנט שאינו מערך. קמפלו עם -Wall.
• %s בלי רוחב. גלישת buffer שמחכה לקלט ארוך.
• התעלמות מהערך המוחזר. ואז קריאה של משתנה ש-scanf מעולם לא השימה בו ערך.
• לולאה על scanf שנכשלה בלי לזרוק את הקלט. לולאה אינסופית.
• %c בלי רווח לפניו אחרי קריאת מספר. באג ההנחיה שמדולגת.
• שימוש ב-%f עבור double. השחתה שקטה, scanf צריכה %lf.
• לצפות ש-%s יקרא שורה. הוא קורא מילה אחת שמופרדת ברווחים.