Biblioteka standardowa C: mapa nagłówków, które warto znać

Sam język C jest malutki: typy, operatory, sterowanie przepływem, funkcje, wskaźniki. Nie potrafi niczego wypisać, przeczytać pliku, porównać napisów ani zaalokować pamięci. Wszystko to zapewnia biblioteka standardowa: zestaw nagłówków dostarczany przez każdą zgodną ze standardem implementację.

Ta strona to mapa. Każda sekcja mówi, do czego służy nagłówek, pokazuje jeden krótki działający przykład i odsyła do pełniejszej strony, jeśli taka istnieje.

stdio.h: wejście i wyjście

Nagłówek, który dołączasz jako pierwszy niemal w każdym programie. Zawiera printf i scanf, typ FILE i funkcje plikowe oraz bezpieczniejsze funkcje wczytujące całe linie.

#include <stdio.h>

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

    /* fputs pisze bez interpretowania specyfikatorow formatu */
    fputs("Zwykly tekst, bez formatowania\n", stdout);

    /* stderr to osobny strumien na komunikaty diagnostyczne */
    fprintf(stderr, "To trafia na standardowe wyjscie bledow\n");

    /* putchar wypisuje jeden znak */
    for (char c = 'a'; c <= 'e'; c++) {
        putchar(c);
    }
    putchar('\n');
    return 0;
}

Podstawy: printf, fprintf, sprintf, snprintf do wypisywania; scanf, fscanf, sscanf, fgets, getchar do wczytywania; fopen, fclose, fread, fwrite, fseek do plików. Dokładniej omawiają je strony printf, scanf i obsługa plików.

Jedna zasada warta zapamiętania: nigdy nie używaj gets(). Ta funkcja nie ma jak poznać rozmiaru bufora i została usunięta ze standardu w C11. Zamiennikiem jest fgets(buf, sizeof buf, stdin).

stdlib.h: narzędzia ogólne

Worek na wszystko: pamięć, konwersje, losowość, sterowanie procesem, sortowanie.

#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) {
    /* z napisu na liczbe */
    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"));

    /* pamiec dynamiczna */
    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 sortuje cokolwiek, jesli dostanie funkcje porownujaca */
    qsort(nums, 5, sizeof *nums, compare_ints);
    for (int i = 0; i < 5; i++) {
        printf("%d ", nums[i]);
    }
    printf("\n");

    free(nums);
    return 0;
}

Najważniejsze: malloc, calloc, realloc, free (zobacz pamięć dynamiczna); atoi, atof, strtol, strtod do konwersji, przy czym lepsza jest rodzina strto*, która potrafi zgłosić błąd, podczas gdy atoi po cichu zwraca 0; rand i srand (zobacz liczby losowe); exit, abort, getenv, system; oraz qsort/bsearch.

string.h: napisy i bloki pamięci

Napisy w C to tablice char zakończone '\0', a każda operacja na nich to wywołanie funkcji.

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

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

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

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

    printf("strcmp  : %d\n", strcmp("banan", "jablko"));
    printf("strchr  : %s\n", strchr(dest, 's'));
    printf("strstr  : %s\n", strstr(dest, "swiecie"));

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

    /* funkcje mem* dzialaja na surowych bajtach, nie tylko na tekscie */
    char block[10];
    memset(block, '-', 9);
    block[9] = '\0';
    printf("memset  : %s\n", block);
    return 0;
}

Dwa nawyki chronią przed tym, by ten nagłówek stał się źródłem przepełnień bufora: zawsze znaj rozmiar miejsca docelowego i pamiętaj, że strcmp zwraca 0 dla równych napisów, więc if (strcmp(a, b)) jest prawdziwe, gdy napisy się różnią. Strona funkcje napisowe szczegółowo omawia bezpieczniejsze wzorce z strncpy/snprintf.

math.h: matematyka

sqrt, pow, fabs, floor, ceil, round, fmod, rodziny funkcji trygonometrycznych i logarytmów, INFINITY i 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;
}

To jedyny nagłówek, który może wymagać flagi linkera: na Linuksie dodaj -lm na końcu polecenia kompilacji, inaczej linker zgłosi „undefined reference to sqrt”. Pełny przegląd na stronie funkcje matematyczne.

time.h: zegary i daty

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

int main(void) {
    time_t now = time(NULL);
    printf("Sekundy od 1970: %ld\n", (long) now);
    printf("Czas lokalny: %s", ctime(&now));

    struct tm *lt = localtime(&now);
    printf("Rok: %d, miesiac: %d, dzien: %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("Sformatowane: %s\n", buf);

    /* clock() mierzy czas procesora zuzyty przez ten program */
    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("Petla zajela %.4f s czasu CPU\n", secs);
    return 0;
}

Dwa przesunięcia w struct tm łapią każdego: tm_year liczy się od 1900, a tm_mon jest numerowane od 0. time(NULL) to też zwyczajowe ziarno dla srand.

ctype.h: klasyfikacja znaków

Mały nagłówek, ale bardziej przydatny, niż się wydaje. Każda funkcja przyjmuje znak i odpowiada na pytanie tak/nie albo zmienia wielkość liter.

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

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

    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("litery=%d cyfry=%d spacje=%d interpunkcja=%d\n",
           letters, digits, spaces, punct);

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

Pełny zestaw: isalpha, isdigit, isalnum, isspace, isupper, islower, ispunct, isxdigit, isprint, a do tego toupper i tolower.

Zwróć uwagę na rzutowanie (unsigned char). Te funkcje są zdefiniowane dla wartości, które da się przedstawić jako unsigned char, oraz dla EOF. Zwykły char jest na większości systemów typem ze znakiem, więc bajt powyżej 127 przychodzi jako liczba ujemna, a wywołanie staje się niezdefiniowanym zachowaniem. Rzutowanie nic nie kosztuje i usuwa całą klasę problemów.

I wybieraj te funkcje zamiast ręcznych testów. c >= '0' && c <= '9' akurat działa, ale isdigit(c) mówi, o co ci chodzi, i pozostaje poprawne wszędzie.

limits.h i float.h: granice typów

Jak duży może być int na tej maszynie? Te nagłówki na to odpowiadają, a odpowiedzi pokazują, dlaczego przenośny kod pyta, zamiast zakładać.

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

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

    printf("float : od %g do %g (bajty: %zu)\n", FLT_MIN, FLT_MAX, sizeof(float));
    printf("double: od %g do %g (bajty: %zu)\n", DBL_MIN, DBL_MAX, sizeof(double));
    printf("precyzja double w cyfrach dziesietnych: %d\n", DBL_DIG);
    return 0;
}

INT_MAX pozwala sprawdzić przepełnienie zanim nastąpi, a to ważne, bo przepełnienie liczby ze znakiem to niezdefiniowane zachowanie, a nie zawinięcie wartości, które można sprawdzić po fakcie.

stdbool.h i stdint.h: lepsze typy

C nie miało typu logicznego aż do C99. Dostarcza go <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 i false to makra dla _Bool, 1 i 0, ale sprawiają, że intencja jest oczywista. (W C23 stały się słowami kluczowymi i nagłówek nie jest już wymagany.)

<stdint.h> daje typy o gwarantowanej szerokości, niezbędne w formatach plików, protokołach sieciowych i wszystkim, co wbudowane, gdzie „int ma pewnie 32 bity” to za mało:

#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("rozmiary: %zu %zu %zu %zu\n",
           sizeof small, sizeof port, sizeof count, sizeof big);
    return 0;
}

Makra w stylu PRId32 z <inttypes.h> rozwijają się do właściwego specyfikatora printf dla każdego typu o stałej szerokości na danej platformie. To przenośny sposób ich wypisywania, bo %d jest poprawne dla int32_t na niektórych systemach, a na innych nie.

assert.h: sprawdzanie założeń

assert(expr) nic nie robi, gdy wyrażenie jest prawdziwe, i przerywa program z komunikatem, gdy jest fałszywe.

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

int divide(int a, int b) {
    assert(b != 0);          /* umowa: wywolujacy nie moze przekazac 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) w tym miejscu przerwaloby program z:
       Assertion `b != 0' failed. */
    return 0;
}

Kompilacja z -DNDEBUG usuwa wszystkie asercje, więc w wersji produkcyjnej nic nie kosztują. To jest też ostrzeżenie: nigdy nie umieszczaj efektu ubocznego wewnątrz assert. assert(read_next() > 0) w wersji produkcyjnej całkowicie przestaje czytać, a wynikający z tego błąd pojawia się tylko na produkcji.

Asercje są na twoje błędy, czyli warunki, które przy poprawnym kodzie powinny być niemożliwe. Złe dane od użytkownika to nie asercja, tylko if i komunikat o błędzie.

Reszta w skrócie

• <stddef.h>: size_t, ptrdiff_t, NULL, offsetof
• <stdarg.h>: funkcje o zmiennej liczbie argumentów, mechanizm stojący za printf
• <errno.h>: errno oraz perror i strerror do zgłaszania, dlaczego wywołanie się nie powiodło
• <signal.h>: obsługa sygnałów, takich jak Ctrl-C
• <setjmp.h>: skoki nielokalne, rzadko właściwa odpowiedź
• <locale.h>, <wchar.h>, <wctype.h>: ustawienia regionalne i szerokie znaki
• <stdnoreturn.h>, <stdalign.h>, <threads.h>, <stdatomic.h>: dodatki z C11

Dwa nawyki sprawiają, że z biblioteki korzysta się przyjemnie. Przeczytaj stronę podręcznika, zanim zaczniesz zgadywać sygnaturę: man 3 strtol na macOS i Linuksie jest źródłem autorytatywnym i szybkim. I sprawdzaj wartości zwracane: malloc, fopen i strtol zgłaszają błędy, a program, który je ignoruje, psuje się znacznie później i w dużo mniej czytelny sposób.