הספרייה הסטנדרטית של C: מפה של קבצי ה-header ששווה להכיר

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

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

stdio.h: קלט ופלט

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

#include <stdio.h>

int main(void) {
    printf("Formatted: %d %s %.2f %c\n", 42, "text", 3.14159, 'X');

    /* fputs כותבת בלי לפרש format specifiers */
    fputs("Plain output, no formatting\n", stdout);

    /* stderr הוא stream נפרד להודעות אבחון */
    fprintf(stderr, "This goes to standard error\n");

    /* putchar כותבת תו בודד */
    for (char c = 'a'; c <= 'e'; c++) {
        putchar(c);
    }
    putchar('\n');
    return 0;
}

היסודות: printf, fprintf, sprintf, snprintf לפלט, scanf, fscanf, sscanf, fgets, getchar לקלט, ו-fopen, fclose, fread, fwrite, fseek לקבצים. כיסוי מעמיק יותר נמצא ב-printf, ב-scanf ובטיפול בקבצים.

כלל אחד ששווה לזכור: לעולם אל תשתמשו ב-gets(). אין לה שום דרך לדעת את גודל ה-buffer שלכם, והיא הוסרה מהתקן ב-C11. fgets(buf, sizeof buf, stdin) היא התחליף.

stdlib.h: כלים כלליים

ה-header של הכול: זיכרון, המרות, אקראיות, בקרת תהליכים, מיון.

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

int compare_ints(const void *a, const void *b) {
    int x = *(const int *)a;
    int y = *(const int *)b;
    return (x > y) - (x < y);
}

int main(void) {
    /* ממחרוזת למספר */
    printf("atoi(\"123\")     = %d\n", atoi("123"));
    printf("strtol(\"ff\", 16) = %ld\n", strtol("ff", NULL, 16));
    printf("atof(\"3.5\")     = %.2f\n", atof("3.5"));

    /* זיכרון דינמי */
    int *nums = malloc(5 * sizeof *nums);
    if (nums == NULL) {
        return 1;
    }
    int seed_values[] = {50, 10, 40, 20, 30};
    for (int i = 0; i < 5; i++) {
        nums[i] = seed_values[i];
    }

    /* qsort ממיינת כל דבר, בהינתן פונקציית השוואה */
    qsort(nums, 5, sizeof *nums, compare_ints);
    for (int i = 0; i < 5; i++) {
        printf("%d ", nums[i]);
    }
    printf("\n");

    free(nums);
    return 0;
}

עיקרי הדברים: malloc, calloc, realloc, free (ראו זיכרון דינמי), atoi, atof, strtol, strtod להמרות, כשעדיף להשתמש במשפחת strto*, שיכולה לדווח על כישלון במקום ש-atoi מחזירה 0 בשקט, rand ו-srand (ראו מספרים אקראיים), exit, abort, getenv, system, ו-qsort/bsearch.

string.h: מחרוזות ובלוקים של זיכרון

מחרוזות ב-C הן מערכים של char שמסתיימים ב-'\0', וכל פעולה עליהן היא קריאה לפונקציה.

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

int main(void) {
    char dest[64] = "Hello";

    printf("strlen  : %zu\n", strlen(dest));

    strcat(dest, ", world");
    printf("strcat  : %s\n", dest);

    printf("strcmp  : %d\n", strcmp("apple", "banana"));
    printf("strchr  : %s\n", strchr(dest, 'w'));
    printf("strstr  : %s\n", strstr(dest, "world"));

    char copy[64];
    strcpy(copy, dest);
    printf("strcpy  : %s\n", copy);

    /* פונקציות mem* עובדות על בתים גולמיים, לא רק על טקסט */
    char block[10];
    memset(block, '-', 9);
    block[9] = '\0';
    printf("memset  : %s\n", block);
    return 0;
}

שני הרגלים מונעים מה-header הזה להפוך למקור של גלישות buffer: תמיד דעו את גודל היעד, וזכרו ש-strcmp מחזירה 0 כשהמחרוזות שוות, כלומר if (strcmp(a, b)) מתקיים כשהמחרוזות שונות. פונקציות מחרוזות מסביר בפירוט את הדפוסים הבטוחים יותר עם strncpy/snprintf.

math.h: מתמטיקה

sqrt, pow, fabs, floor, ceil, round, fmod, משפחות הטריגונומטריה והלוגריתמים, INFINITY ו-NAN.

#include <stdio.h>
#include <math.h>

int main(void) {
    printf("sqrt(2)     = %.6f\n", sqrt(2.0));
    printf("pow(2, 10)  = %.0f\n", pow(2.0, 10.0));
    printf("ceil(4.1)   = %.0f\n", ceil(4.1));
    printf("fabs(-9.5)  = %.1f\n", fabs(-9.5));
    return 0;
}

זה ה-header היחיד שעשוי לדרוש דגל ל-linker: ב-Linux, הוסיפו -lm בסוף פקודת הקומפילציה, אחרת ה-linker מדווח "undefined reference to sqrt". סיור מלא בפונקציות מתמטיות.

time.h: שעונים ותאריכים

#include <stdio.h>
#include <time.h>

int main(void) {
    time_t now = time(NULL);
    printf("Seconds since 1970: %ld\n", (long) now);
    printf("Local time: %s", ctime(&now));

    struct tm *lt = localtime(&now);
    printf("Year: %d, month: %d, day: %d\n",
           lt->tm_year + 1900, lt->tm_mon + 1, lt->tm_mday);

    char buf[64];
    strftime(buf, sizeof buf, "%Y-%m-%d %H:%M:%S", lt);
    printf("Formatted: %s\n", buf);

    /* clock() מודדת את זמן המעבד שהתוכנית הזו השתמשה בו */
    clock_t start = clock();
    volatile long sum = 0;
    for (long i = 0; i < 3000000L; i++) {
        sum += i;
    }
    double secs = (double)(clock() - start) / CLOCKS_PER_SEC;
    printf("Loop took %.4f CPU seconds\n", secs);
    return 0;
}

שני ההיסטים ב-struct tm תופסים את כולם: tm_year נספר מ-1900, ו-tm_mon מתחיל מ-0. time(NULL) היא גם ה-seed הרגיל ל-srand.

ctype.h: סיווג תווים

קטן, ושימושי יותר ממה שהוא נראה. כל פונקציה מקבלת תו ועונה על שאלת כן/לא, או ממירה בין אותיות גדולות לקטנות.

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

int main(void) {
    const char *text = "Coddy C17, launched!";

    int letters = 0, digits = 0, spaces = 0, punct = 0;
    for (const char *p = text; *p != '\0'; p++) {
        unsigned char c = (unsigned char) *p;
        if (isalpha(c))      letters++;
        else if (isdigit(c)) digits++;
        else if (isspace(c)) spaces++;
        else if (ispunct(c)) punct++;
    }
    printf("letters=%d digits=%d spaces=%d punctuation=%d\n",
           letters, digits, spaces, punct);

    printf("Upper: ");
    for (const char *p = text; *p != '\0'; p++) {
        putchar(toupper((unsigned char) *p));
    }
    printf("\n");
    return 0;
}

הסט המלא: isalpha, isdigit, isalnum, isspace, isupper, islower, ispunct, isxdigit, isprint, ובנוסף toupper ו-tolower.

שימו לב ל-cast ל-(unsigned char). הפונקציות האלה מוגדרות לערכים שאפשר לייצג כ-unsigned char ועוד EOF. char רגיל הוא signed ברוב המערכות, כך שבית מעל 127 מגיע כמספר שלילי והקריאה הופכת ל-undefined behavior. ה-cast לא עולה כלום ומעלים את כל סוג הבעיה הזה.

והעדיפו אותן על בדיקות שכתבתם בעצמכם. c >= '0' && c <= '9' במקרה עובד, אבל isdigit(c) אומר את מה שאתם מתכוונים ונשאר נכון בכל מקום.

limits.h ו-float.h: הקצוות של הטיפוסים

כמה גדול יכול להיות int במכונה הזו? ה-headers האלה עונים על זה, והתשובות הן הסיבה שקוד נייד שואל במקום להניח.

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

int main(void) {
    printf("char  : %d to %d (%zu byte)\n", CHAR_MIN, CHAR_MAX, sizeof(char));
    printf("int   : %d to %d (%zu bytes)\n", INT_MIN, INT_MAX, sizeof(int));
    printf("long  : %ld to %ld (%zu bytes)\n", LONG_MIN, LONG_MAX, sizeof(long));
    printf("uint  : 0 to %u\n", UINT_MAX);

    printf("float : %g to %g (%zu bytes)\n", FLT_MIN, FLT_MAX, sizeof(float));
    printf("double: %g to %g (%zu bytes)\n", DBL_MIN, DBL_MAX, sizeof(double));
    printf("double has %d decimal digits of precision\n", DBL_DIG);
    return 0;
}

INT_MAX הוא הדרך לבדוק גלישה לפני שהיא קורית, וזה חשוב כי גלישה של מספר עם סימן היא undefined behavior, ולא גלגול שאפשר לבדוק אחר כך.

stdbool.h ו-stdint.h: טיפוסים טובים יותר

ל-C לא היה טיפוס בוליאני עד C99. <stdbool.h> מספק אחד:

#include <stdio.h>
#include <stdbool.h>

bool is_even(int n) {
    return n % 2 == 0;
}

int main(void) {
    bool ready = true;
    bool done  = false;

    printf("ready=%d done=%d\n", ready, done);
    printf("is_even(10) = %s\n", is_even(10) ? "true" : "false");
    return 0;
}

bool, true ו-false הם מאקרו עבור _Bool, 1 ו-0, אבל הם הופכים את הכוונה לברורה. (ב-C23 הם הפכו למילות מפתח, וה-header כבר לא נדרש.)

<stdint.h> נותן טיפוסים עם רוחב מובטח. זה חיוני לפורמטים של קבצים, לפרוטוקולי רשת ולכל דבר embedded, שם "int הוא כנראה 32 ביט" לא מספיק טוב:

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

int main(void) {
    int8_t   small = -128;
    uint16_t port  = 8080;
    int32_t  count = 2000000000;
    uint64_t big   = 18000000000000000000ULL;

    printf("int8_t  : %" PRId8  "\n", small);
    printf("uint16_t: %" PRIu16 "\n", port);
    printf("int32_t : %" PRId32 "\n", count);
    printf("uint64_t: %" PRIu64 "\n", big);

    printf("sizes: %zu %zu %zu %zu\n",
           sizeof small, sizeof port, sizeof count, sizeof big);
    return 0;
}

המאקרו בסגנון PRId32 מ-<inttypes.h> מתרחבים ל-specifier הנכון של printf לכל טיפוס ברוחב קבוע בפלטפורמה הנוכחית. זו הדרך הניידת להדפיס אותם, כי %d נכון עבור int32_t במערכות מסוימות ושגוי באחרות.

assert.h: בדיקת ההנחות שלכם

assert(expr) לא עושה כלום כשהביטוי אמת, ועוצרת את התוכנית עם הודעה כשהוא שקר.

#include <stdio.h>
#include <assert.h>

int divide(int a, int b) {
    assert(b != 0);          /* חוזה: אסור לקוראים להעביר 0 */
    return a / b;
}

int main(void) {
    printf("20 / 4 = %d\n", divide(20, 4));
    printf("20 / 5 = %d\n", divide(20, 5));

    /* divide(20, 0) כאן הייתה עוצרת עם:
       Assertion `b != 0' failed. */
    return 0;
}

קומפילציה עם -DNDEBUG מסירה את כל ה-assertions, כך שהן לא עולות כלום ב-build של release. זו גם האזהרה: לעולם אל תשימו תופעת לוואי בתוך assert. assert(read_next() > 0) מפסיק לקרוא לגמרי ב-build של release, והבאג שנוצר מופיע רק בפרודקשן.

assertions הן בשביל הטעויות שלכם: תנאים שאמורים להיות בלתי אפשריים אם הקוד נכון. קלט שגוי של משתמש הוא לא assertion, הוא if והודעת שגיאה.

השאר, בקצרה

• <stddef.h>: size_t, ptrdiff_t, NULL, offsetof
• <stdarg.h>: פונקציות variadic, המנגנון שמאחורי printf
• <errno.h>: errno, ובנוסף perror ו-strerror לדיווח למה קריאה נכשלה
• <signal.h>: טיפול באותות כמו Ctrl-C
• <setjmp.h>: קפיצות לא מקומיות, ולעיתים רחוקות התשובה הנכונה
• <locale.h>, <wchar.h>, <wctype.h>: locales ותווים רחבים
• <stdnoreturn.h>, <stdalign.h>, <threads.h>, <stdatomic.h>: תוספות של C11

שני הרגלים הופכים את השימוש בספרייה לנעים. קראו את דף ה-manual לפני שאתם מנחשים חתימה: man 3 strtol ב-macOS וב-Linux הוא סמכותי ומהיר. ובדקו ערכים מוחזרים: malloc, fopen ו-strtol כולן מדווחות על כישלון, ותוכנית שמתעלמת מהן נכשלת הרבה יותר מאוחר ובצורה הרבה פחות ברורה.