Ausführbare C-Docs: Standardbibliothek

Q: Was ist der Unterschied zwischen stdio.h und stdlib.h?

ist Ein- und Ausgabe: printf, scanf, fopen, fgets, FILE. sind allgemeine Werkzeuge: malloc und free, atoi und strtol, rand und srand, exit, qsort, bsearch. Ein typisches Programm bindet beide ein.

Q: Was macht ctype.h?

Es klassifiziert und wandelt einzelne Zeichen um: isdigit, isalpha, isalnum, isspace, isupper, islower, ispunct, dazu toupper und tolower. Sie statt handgeschriebener Vergleiche wie c >= '0' && c <= '9' zu benutzen ist klarer und für jede Locale und jeden Zeichensatz korrekt.

Q: Muss ich etwas linken, um die C-Standardbibliothek zu benutzen?

Nein, mit einer Ausnahme: den Mathematikfunktionen. Die Standard-C-Bibliothek wird automatisch gelinkt, aber unter Linux liegen die Implementierungen von in einer eigenen Bibliothek, sqrt und Verwandte brauchen also -lm am Ende des Übersetzungsbefehls. Alles andere braucht nur das richtige #include.

Die Sprache C ist winzig - Typen, Operatoren, Kontrollfluss, Funktionen, Zeiger. Sie kann nichts ausgeben, keine Datei lesen, keine Zeichenkette vergleichen und keinen Speicher belegen. All das ist die Standardbibliothek: ein Satz Header, den jede standardkonforme Implementierung ausliefert.

Diese Seite ist eine Karte. Jeder Abschnitt sagt, wofür ein Header da ist, zeigt ein kurzes lauffähiges Beispiel und verweist auf die ausführlichere Seite, wo es eine gibt.

stdio.h - Ein- und Ausgabe

Der Header, den du in fast jedem Programm zuerst einbindest. Er hält printf und scanf, den Typ FILE und die Dateifunktionen sowie die sichereren zeilenorientierten Eingabefunktionen.

#include <stdio.h>

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

    /* fputs schreibt, ohne Formatangaben zu deuten */
    fputs("Einfache Ausgabe, keine Formatierung\n", stdout);

    /* stderr ist ein eigener Strom fuer Diagnosen */
    fprintf(stderr, "Das geht nach der Standardfehlerausgabe\n");

    /* putchar schreibt ein einzelnes Zeichen */
    for (char c = 'a'; c <= 'e'; c++) {
        putchar(c);
    }
    putchar('\n');
    return 0;
}

Das Wesentliche: printf, fprintf, sprintf, snprintf für die Ausgabe; scanf, fscanf, sscanf, fgets, getchar für die Eingabe; fopen, fclose, fread, fwrite, fseek für Dateien. Tiefere Behandlung steht unter printf, scanf und Dateiverarbeitung.

Eine Regel, die man mitnehmen sollte: Benutze nie gets(). Es hat keine Möglichkeit, die Größe deines Puffers zu kennen, und wurde in C11 aus dem Standard entfernt. fgets(buf, sizeof buf, stdin) ist der Ersatz.

stdlib.h - allgemeine Werkzeuge

Das Sammelbecken: Speicher, Umwandlungen, Zufall, Prozesssteuerung, Sortieren.

#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) {
    /* Zeichenkette in Zahl */
    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"));

    /* dynamischer Speicher */
    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 sortiert alles, wenn es eine Vergleichsfunktion bekommt */
    qsort(nums, 5, sizeof *nums, compare_ints);
    for (int i = 0; i < 5; i++) {
        printf("%d ", nums[i]);
    }
    printf("\n");

    free(nums);
    return 0;
}

Höhepunkte: malloc, calloc, realloc, free (siehe dynamischer Speicher); atoi, atof, strtol, strtod für Umwandlungen - bevorzuge die strto*-Familie, die einen Fehlschlag melden kann, wo atoi still 0 liefert; rand und srand (siehe Zufallszahlen); exit, abort, getenv, system; sowie qsort/bsearch.

string.h - Zeichenketten und Speicherblöcke

C-Zeichenketten sind char-Arrays, die mit '\0' enden, und jede Operation auf ihnen ist ein Funktionsaufruf.

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

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

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

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

    printf("strcmp  : %d\n", strcmp("Apfel", "Banane"));
    printf("strchr  : %s\n", strchr(dest, 'W'));
    printf("strstr  : %s\n", strstr(dest, "Welt"));

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

    /* die mem*-Funktionen arbeiten auf rohen Bytes, nicht nur auf Text */
    char block[10];
    memset(block, '-', 9);
    block[9] = '\0';
    printf("memset  : %s\n", block);
    return 0;
}

Zwei Gewohnheiten bewahren diesen Header davor, eine Quelle von Pufferüberläufen zu werden: Kenne immer die Größe des Ziels, und denk daran, dass strcmp bei Gleichheit 0 liefert - if (strcmp(a, b)) ist wahr, wenn die Zeichenketten sich unterscheiden. Zeichenkettenfunktionen behandelt die sichereren strncpy/snprintf-Muster ausführlich.

math.h - Mathematik

sqrt, pow, fabs, floor, ceil, round, fmod, die Trigonometrie- und Logarithmusfamilien, INFINITY und 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;
}

Das ist der eine Header, der ein Linker-Flag brauchen kann: Füge unter Linux -lm ans Ende des Übersetzungsbefehls, sonst meldet der Linker „undefined reference to sqrt". Die volle Tour steht unter Mathematikfunktionen.

time.h - Uhren und Daten

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

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

    struct tm *lt = localtime(&now);
    printf("Jahr: %d, Monat: %d, Tag: %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("Formatiert: %s\n", buf);

    /* clock() misst die von diesem Programm verbrauchte Prozessorzeit */
    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("Die Schleife brauchte %.4f CPU-Sekunden\n", secs);
    return 0;
}

Die zwei Verschiebungen in struct tm erwischen jeden: tm_year zählt ab 1900, und tm_mon ist nullbasiert. time(NULL) ist auch der übliche Startwert für srand.

ctype.h - Zeichenklassifizierung

Klein und nützlicher, als es aussieht. Jede Funktion nimmt ein Zeichen entgegen und beantwortet eine Ja/Nein-Frage oder wandelt die Groß-/Kleinschreibung um.

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

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

    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("Buchstaben=%d Ziffern=%d Leerzeichen=%d Satzzeichen=%d\n",
           letters, digits, spaces, punct);

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

Der vollständige Satz: isalpha, isdigit, isalnum, isspace, isupper, islower, ispunct, isxdigit, isprint, dazu toupper und tolower.

Beachte den Cast (unsigned char). Diese Funktionen sind für Werte definiert, die als unsigned char darstellbar sind, plus EOF; ein schlichtes char ist auf den meisten Systemen vorzeichenbehaftet, ein Byte über 127 kommt also als negative Zahl an und der Aufruf wird zu undefiniertem Verhalten. Der Cast kostet nichts und beseitigt die ganze Problemklasse.

Und bevorzuge sie gegenüber selbstgebauten Tests. c >= '0' && c <= '9' funktioniert zufällig, aber isdigit(c) sagt, was du meinst, und bleibt überall korrekt.

limits.h und float.h - die Ränder der Typen

Wie groß kann ein int auf dieser Maschine werden? Diese Header beantworten das, und die Antworten sind der Grund, warum portabler Code fragt statt anzunehmen.

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

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

    printf("float : %g bis %g (%zu Bytes)\n", FLT_MIN, FLT_MAX, sizeof(float));
    printf("double: %g bis %g (%zu Bytes)\n", DBL_MIN, DBL_MAX, sizeof(double));
    printf("double hat %d Dezimalstellen Genauigkeit\n", DBL_DIG);
    return 0;
}

INT_MAX ist die Art, auf einen Überlauf zu prüfen, bevor er passiert, und das zählt, weil ein vorzeichenbehafteter Überlauf undefiniertes Verhalten ist und kein Umschlagen, das du hinterher testen könntest.

stdbool.h und stdint.h - bessere Typen

C hatte bis C99 keinen Wahrheitstyp. <stdbool.h> liefert einen:

#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) ? "wahr" : "falsch");
    return 0;
}

bool, true und false sind Makros für _Bool, 1 und 0, aber sie machen die Absicht offensichtlich. (In C23 wurden sie Schlüsselwörter und der Header ist nicht mehr nötig.)

<stdint.h> gibt dir Typen mit garantierten Breiten - unverzichtbar für Dateiformate, Netzprotokolle und alles Eingebettete, wo „ein int hat wahrscheinlich 32 Bit" nicht gut genug ist:

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

Die Makros im Stil PRId32 aus <inttypes.h> expandieren zur korrekten printf-Angabe für jeden Typ fester Breite auf der aktuellen Plattform - und das ist die portable Art, sie auszugeben, denn %d ist auf manchen Systemen für int32_t richtig und auf anderen falsch.

assert.h - deine Annahmen prüfen

assert(ausdruck) tut nichts, wenn der Ausdruck wahr ist, und bricht das Programm mit einer Meldung ab, wenn er falsch ist.

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

int divide(int a, int b) {
    assert(b != 0);          /* ein Vertrag: Aufrufer duerfen keine 0 uebergeben */
    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) hier wuerde abbrechen mit:
       Assertion `b != 0' failed. */
    return 0;
}

Mit -DNDEBUG zu kompilieren entfernt jede Zusicherung, sie kosten in einem Release-Build also nichts. Das ist zugleich die Warnung: Setze nie eine Nebenwirkung in ein assert. assert(read_next() > 0) hört im Release-Build ganz auf zu lesen, und der entstehende Bug taucht nur in der Produktion auf.

Zusicherungen sind für deine Fehler gedacht - Bedingungen, die unmöglich sein sollten, wenn der Code korrekt ist. Eine schlechte Benutzereingabe ist keine Zusicherung; sie ist ein if und eine Fehlermeldung.

Der Rest, kurz gefasst

<stddef.h> - size_t, ptrdiff_t, NULL, offsetof
<stdarg.h> - Funktionen mit variabler Argumentzahl, die Maschinerie hinter printf
<errno.h> - errno plus perror und strerror, um zu melden, warum ein Aufruf scheiterte
<signal.h> - Signale behandeln, etwa Strg-C
<setjmp.h> - nichtlokale Sprünge; selten die richtige Antwort
<locale.h>, <wchar.h>, <wctype.h> - Locales und breite Zeichen
<stdnoreturn.h>, <stdalign.h>, <threads.h>, <stdatomic.h> - Ergänzungen aus C11

Zwei Gewohnheiten machen die Bibliothek angenehm zu benutzen. Lies die Handbuchseite, statt eine Signatur zu erraten - man 3 strtol unter macOS und Linux ist maßgeblich und schnell. Und prüfe Rückgabewerte: malloc, fopen und strtol melden alle einen Fehlschlag, und ein Programm, das sie ignoriert, scheitert viel später und viel unklarer.

Häufig gestellte Fragen

Was ist die C-Standardbibliothek?

Die Menge an Funktionen, Typen und Makros, die jede standardkonforme C-Implementierung bereitstellt, gruppiert in etwa 30 Header. Sie deckt Ein- und Ausgabe (<stdio.h>), Speicher und Umwandlungen (<stdlib.h>), Zeichenketten (<string.h>), Mathematik (<math.h>), Zeit, Zeichenklassifizierung und die Grenzen der numerischen Typen ab. C hat keine eingebaute Ein-/Ausgabe und keine Zeichenkettenverarbeitung - alles davon kommt von hier.

Was ist der Unterschied zwischen stdio.h und stdlib.h?

<stdio.h> ist Ein- und Ausgabe: printf, scanf, fopen, fgets, FILE. <stdlib.h> sind allgemeine Werkzeuge: malloc und free, atoi und strtol, rand und srand, exit, qsort, bsearch. Ein typisches Programm bindet beide ein.

Was macht ctype.h?

Es klassifiziert und wandelt einzelne Zeichen um: isdigit, isalpha, isalnum, isspace, isupper, islower, ispunct, dazu toupper und tolower. Sie statt handgeschriebener Vergleiche wie c >= '0' && c <= '9' zu benutzen ist klarer und für jede Locale und jeden Zeichensatz korrekt.

Muss ich etwas linken, um die C-Standardbibliothek zu benutzen?

Nein, mit einer Ausnahme: den Mathematikfunktionen. Die Standard-C-Bibliothek wird automatisch gelinkt, aber unter Linux liegen die Implementierungen von <math.h> in einer eigenen Bibliothek, sqrt und Verwandte brauchen also -lm am Ende des Übersetzungsbefehls. Alles andere braucht nur das richtige #include.

Verwandte Konzepte