המרת מחרוזת ל-int ב-C: atoi, strtol והמרת מספרים לטקסט

טקסט מגיע ממשתמשים, מקבצים ומשורת הפקודה כתווים. "42" הוא שלושה בתים, '4', '2', '\0', ושום דבר בו הוא המספר 42 עד שממירים אותו. C מציעה שני דורות של פונקציות המרה: הישנות והקצרות שלא יכולות לדווח על שגיאות, והארוכות יותר שכן. העמוד הזה מציג את שתיהן ומסביר למה תוכניות אמיתיות משתמשות בסט השני.

המשפחה הישנה: atoi, atol, atof

השמות שלהן אומרים הכול: ASCII ל-int, ל-long, ל-double. ארגומנט אחד, תוצאה אחת.

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

int main(void) {
    printf("%d\n", atoi("42"));
    printf("%d\n", atoi("  -17 trailing junk"));
    printf("%f\n", atof("3.14"));
    return 0;
}

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

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

int main(void) {
    printf("atoi(\"0\")     = %d\n", atoi("0"));
    printf("atoi(\"hello\") = %d\n", atoi("hello"));
    printf("atoi(\"\")      = %d\n", atoi(""));
    return 0;
}

שלושתן מדפיסות 0. אין קוד חזרה, אין דגל, אין דרך לשאול "זה עבד?", וערך שגולש מ-int הוא undefined behavior ולא שגיאה מדווחת. לליטרל קבוע בתוכנית צעצוע זה נסבל. לכל דבר שאדם או קובץ יכולים לספק, זה מחולל באגים שקטים.

הכלי הנכון: strtol

strtol (string to long) היא אותה המרה עם שני ערוצים לדיווח על מה שקרה.

long strtol(const char *text, char **endptr, int base);

endptr מקבל את התו הראשון שהפונקציה לא צרכה. base הוא בסיס הספירה: השתמשו ב-10, או ב-0 כדי לתת לקידומת של הליטרל עצמו להחליט (0x להקסדצימלי, 0 בהתחלה לאוקטלי).

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

int main(void) {
    const char *input = "42 apples";
    char *end;

    long value = strtol(input, &end, 10);

    printf("value = %ld\n", value);
    printf("stopped at: \"%s\"\n", end);
    printf("consumed %td characters\n", end - input);
    return 0;
}

קריאת endptr עונה על השאלות ש-atoi לא יכולה:

• end == input אומר ששום דבר לא הומר: הטקסט לא התחיל במספר.
• *end != '\0' אומר שהיה תוכן בסוף. אם זו שגיאה, זו החלטה שלכם: זה בסדר כשמנתחים את "42 apples", ובעיה כשכל השורה הייתה אמורה להיות מספר.

גלישה מדווחת בנפרד דרך errno. את הניב המלא והנכון שווה לכתוב פעם אחת ולהשתמש בו שוב:

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

/* מחזירה 1 בהצלחה, ו-0 בכל סוג של כישלון */
int parse_int(const char *text, int *out) {
    char *end;
    errno = 0;

    long value = strtol(text, &end, 10);

    if (end == text) {
        return 0;                 /* אין ספרות בכלל */
    }
    if (*end != '\0') {
        return 0;                 /* זבל בסוף */
    }
    if (errno == ERANGE || value < INT_MIN || value > INT_MAX) {
        return 0;                 /* מחוץ לטווח של int */
    }

    *out = (int)value;
    return 1;
}

int main(void) {
    const char *tests[] = {"42", "-7", "hello", "", "9999999999", "12abc"};
    int n = (int)(sizeof tests / sizeof tests[0]);

    for (int i = 0; i < n; i++) {
        int value;
        if (parse_int(tests[i], &value)) {
            printf("\"%s\" -> %d\n", tests[i], value);
        } else {
            printf("\"%s\" -> rejected\n", tests[i]);
        }
    }
    return 0;
}

שלושה פרטים הופכים את זה לנכון. errno = 0 לפני הקריאה חשוב, כי הספרייה רק מציבה ערך ב-errno ואף פעם לא מנקה אותו, כך שערך ישן מקריאה קודמת היה נקרא ככישלון של הקריאה הזו. strtol מחזירה long, שעשוי להיות רחב יותר מ-int, ולכן בדיקת הטווח מול INT_MIN/INT_MAX נפרדת מ-ERANGE. והחזרת הצלחה כסטטוס תוך מסירת הערך דרך מצביע היא הדרך שבה פונקציות C מדווחות "או ערך או כישלון": הערך המוחזר לא יכול לעשות את שתי העבודות.

strtoul היא המקבילה ל-unsigned, ו-strtoll/strtoull מטפלות ב-long long.

בסיסים אחרים

בסיס 16 קורא הקסדצימלי, ובסיס 0 בודק את הקידומת ומחליט בעצמו.

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

int main(void) {
    char *end;

    printf("%ld\n", strtol("ff", &end, 16));      /* 255 */
    printf("%ld\n", strtol("0x1A", &end, 0));     /* 26, הקידומת זוהתה */
    printf("%ld\n", strtol("1011", &end, 2));     /* 11, בינארי */
    printf("%ld\n", strtol("755", &end, 8));      /* 493, אוקטלי */
    return 0;
}

בסיס 0 הוא מלכודת במקרה ספציפי אחד: מספר עשרוני מרופד באפסים כמו "012" נקרא כאוקטלי ויוצא 10. אם הקלט שלכם עשרוני, כתבו 10 במפורש.

מספרים עשרוניים: strtod

strtod היא אותה צורה עבור double, ול-atof יש אותו פגם כמו ל-atoi.

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

int main(void) {
    const char *text = "3.14159 rest";
    char *end;
    errno = 0;

    double value = strtod(text, &end);

    if (end == text) {
        printf("not a number\n");
    } else if (errno == ERANGE) {
        printf("out of range\n");
    } else {
        printf("value = %f, stopped at \"%s\"\n", value, end);
    }
    return 0;
}

strtod מקבלת גם כתיב מדעי ("1.5e3"), מספרים עשרוניים בהקסדצימלי, ואת המילים "inf" ו-"nan". ה-locale משפיע על המפריד העשרוני, וזה מפתיע אנשים שמנתחים קבצים שנכתבו במקום אחר. ב-locale ברירת המחדל "C" המפריד הוא תמיד נקודה.

ממספרים לטקסט: snprintf

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

#include <stdio.h>

int main(void) {
    char buf[32];
    int n = 4095;

    int written = snprintf(buf, sizeof buf, "%d", n);
    printf("text: \"%s\" (needed %d chars)\n", buf, written);

    snprintf(buf, sizeof buf, "%05d", n);
    printf("padded: %s\n", buf);

    snprintf(buf, sizeof buf, "%x / %o / %.2f", n, n, n / 1000.0);
    printf("mixed:  %s\n", buf);
    return 0;
}

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

#include <stdio.h>

int main(void) {
    char small[8];

    int needed = snprintf(small, sizeof small, "value=%d", 1234567);

    if (needed < 0) {
        printf("encoding error\n");
    } else if ((size_t)needed >= sizeof small) {
        printf("truncated: \"%s\" (needed %d bytes)\n", small, needed + 1);
    } else {
        printf("ok: %s\n", small);
    }
    return 0;
}

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

תווים בודדים ו-'0'

מובטח שתווי הספרות '0' עד '9' רציפים, ולכן חיסור פשוט ממיר בין תו של ספרה לבין הערך שלה.

#include <stdio.h>
#include <ctype.h>

int main(void) {
    char c = '7';
    int digit = c - '0';
    printf("char '%c' -> int %d\n", c, digit);

    int value = 3;
    char back = (char)(value + '0');
    printf("int %d -> char '%c'\n", value, back);
    return 0;
}

רק ספרות מתנהגות כך: אותיות לא חייבות להיות רציפות, ולכן c - 'a' אינו נייד לחשבון עם האלפבית. הגנו על החיסור עם isdigit לפני שסומכים עליו:

#include <stdio.h>
#include <ctype.h>

int main(void) {
    char text[] = "a1b2c3";
    int sum = 0;

    for (int i = 0; text[i] != '\0'; i++) {
        if (isdigit((unsigned char)text[i])) {
            sum += text[i] - '0';
        }
    }

    printf("digits sum to %d\n", sum);
    return 0;
}

ה-cast ל-unsigned char נדרש מאותה סיבה כמו במחרוזות: הפונקציות של <ctype.h> לא מוגדרות לארגומנטים שליליים, ו-char רגיל יכול להיות signed.

באיזו פונקציה להשתמש

• טקסט ממשתמש, מקובץ או מ-argv → strtol / strtod עם הבדיקה המלאה.
• ליטרל שכתבתם בעצמכם ושבשליטתכם → atoi מקובלת, אם כי לא מרשימה.
• מספר לתוך buffer → snprintf, ובדקו את הערך המוחזר.
• תו של ספרה אחת → החסירו '0', אחרי isdigit.
• אף פעם → gets, sprintf, itoa.