La libreria standard del C: una mappa degli header da conoscere

Il C come linguaggio è minuscolo: tipi, operatori, controllo di flusso, funzioni, puntatori. Non sa stampare, leggere un file, confrontare una stringa o allocare memoria. Tutto questo è la libreria standard: un insieme di header che ogni implementazione conforme fornisce.

Questa pagina è una mappa. Ogni sezione dice a cosa serve un header, mostra un breve esempio funzionante e rimanda alla pagina più completa quando esiste.

stdio.h: input e output

L'header che includi per primo in quasi ogni programma. Contiene printf e scanf, il tipo FILE e le funzioni sui file, e le funzioni di input per righe più sicure.

#include <stdio.h>

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

    /* fputs scrive senza interpretare gli specificatori di formato */
    fputs("Output semplice, senza formattazione\n", stdout);

    /* stderr e uno stream separato per la diagnostica */
    fprintf(stderr, "Questo va sullo standard error\n");

    /* putchar scrive un singolo carattere */
    for (char c = 'a'; c <= 'e'; c++) {
        putchar(c);
    }
    putchar('\n');
    return 0;
}

L'essenziale: printf, fprintf, sprintf, snprintf per l'output; scanf, fscanf, sscanf, fgets, getchar per l'input; fopen, fclose, fread, fwrite, fseek per i file. Trovi approfondimenti in printf, scanf e gestione dei file.

Una regola da portarsi dietro: non usare mai gets(). Non ha modo di conoscere la dimensione del tuo buffer ed è stata rimossa dallo standard in C11. Al suo posto si usa fgets(buf, sizeof buf, stdin).

stdlib.h: utilità generali

Il contenitore di tutto: memoria, conversioni, casualità, controllo del processo, ordinamento.

#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) {
    /* da stringa a numero */
    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"));

    /* memoria dinamica */
    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 ordina qualsiasi cosa se le dai una funzione di confronto */
    qsort(nums, 5, sizeof *nums, compare_ints);
    for (int i = 0; i < 5; i++) {
        printf("%d ", nums[i]);
    }
    printf("\n");

    free(nums);
    return 0;
}

Da ricordare: malloc, calloc, realloc, free (vedi memoria dinamica); atoi, atof, strtol, strtod per le conversioni, dove conviene preferire la famiglia strto*, che sa segnalare un errore mentre atoi restituisce 0 in silenzio; rand e srand (vedi numeri casuali); exit, abort, getenv, system; e qsort/bsearch.

string.h: stringhe e blocchi di memoria

Le stringhe C sono array di char che terminano con '\0', e ogni operazione su di esse è una chiamata di funzione.

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

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

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

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

    printf("strcmp  : %d\n", strcmp("mela", "banana"));
    printf("strchr  : %s\n", strchr(dest, 'm'));
    printf("strstr  : %s\n", strstr(dest, "mondo"));

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

    /* le funzioni mem* lavorano su byte grezzi, non solo sul testo */
    char block[10];
    memset(block, '-', 9);
    block[9] = '\0';
    printf("memset  : %s\n", block);
    return 0;
}

Due abitudini evitano che questo header diventi una fonte di buffer overflow: conosci sempre la dimensione della destinazione, e ricorda che strcmp restituisce 0 quando le stringhe sono uguali, quindi if (strcmp(a, b)) è vero quando le stringhe sono diverse. Le funzioni sulle stringhe trattano nel dettaglio gli schemi più sicuri con strncpy/snprintf.

math.h: matematica

sqrt, pow, fabs, floor, ceil, round, fmod, le famiglie trigonometriche e logaritmiche, INFINITY e 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;
}

È l'unico header che può richiedere un'opzione per il linker: su Linux aggiungi -lm alla fine del comando di compilazione, altrimenti il linker segnala "undefined reference to sqrt". Il giro completo è nelle funzioni matematiche.

time.h: orologi e date

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

int main(void) {
    time_t now = time(NULL);
    printf("Secondi dal 1970: %ld\n", (long) now);
    printf("Ora locale: %s", ctime(&now));

    struct tm *lt = localtime(&now);
    printf("Anno: %d, mese: %d, giorno: %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("Formattato: %s\n", buf);

    /* clock() misura il tempo di processore usato da questo programma */
    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("Il ciclo ha richiesto %.4f secondi di CPU\n", secs);
    return 0;
}

I due scostamenti di struct tm fregano tutti: tm_year conta dal 1900 e tm_mon parte da 0. time(NULL) è anche il seme abituale per srand.

ctype.h: classificazione dei caratteri

Piccolo, e più utile di quanto sembri. Ogni funzione riceve un carattere e risponde a una domanda sì/no, oppure converte maiuscole e minuscole.

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

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

    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("lettere=%d cifre=%d spazi=%d punteggiatura=%d\n",
           letters, digits, spaces, punct);

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

L'insieme completo: isalpha, isdigit, isalnum, isspace, isupper, islower, ispunct, isxdigit, isprint, più toupper e tolower.

Nota il cast (unsigned char). Queste funzioni sono definite per i valori rappresentabili come unsigned char più EOF; un char semplice ha il segno sulla maggior parte dei sistemi, quindi un byte sopra 127 arriva come numero negativo e la chiamata diventa comportamento indefinito. Il cast non costa nulla ed elimina l'intera categoria di problemi.

E preferisci queste funzioni ai controlli fatti a mano. c >= '0' && c <= '9' per caso funziona, ma isdigit(c) dice quello che intendi e resta corretto ovunque.

limits.h e float.h: i confini dei tipi

Quanto può diventare grande un int su questa macchina? Questi header rispondono, e le risposte sono il motivo per cui il codice portabile chiede invece di presumere.

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

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

    printf("float : da %g a %g (%zu byte)\n", FLT_MIN, FLT_MAX, sizeof(float));
    printf("double: da %g a %g (%zu byte)\n", DBL_MIN, DBL_MAX, sizeof(double));
    printf("double ha %d cifre decimali di precisione\n", DBL_DIG);
    return 0;
}

INT_MAX è il modo per controllare l'overflow prima che avvenga, ed è importante perché l'overflow con segno è comportamento indefinito, non un giro a capo che puoi verificare dopo.

stdbool.h e stdint.h: tipi migliori

Il C non ha avuto un tipo booleano fino al C99. <stdbool.h> ne fornisce uno:

#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 e false sono macro per _Bool, 1 e 0, ma rendono evidente l'intenzione. (In C23 sono diventate parole chiave e l'header non è più necessario.)

<stdint.h> fornisce tipi con larghezza garantita, essenziali per formati di file, protocolli di rete e tutto ciò che è embedded, dove "un int probabilmente è a 32 bit" non basta:

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

Le macro in stile PRId32 di <inttypes.h> si espandono nello specificatore printf corretto per ogni tipo a larghezza fissa sulla piattaforma corrente: è il modo portabile per stamparli, dato che %d è giusto per int32_t su alcuni sistemi e sbagliato su altri.

assert.h: verificare le tue ipotesi

assert(expr) non fa nulla quando l'espressione è vera e termina il programma con un messaggio quando è falsa.

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

int divide(int a, int b) {
    assert(b != 0);          /* un contratto: i chiamanti non devono passare 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) qui terminerebbe con:
       Assertion `b != 0' failed. */
    return 0;
}

Compilare con -DNDEBUG rimuove tutte le asserzioni, quindi in una build di rilascio non costano nulla. Ed è proprio questo l'avvertimento: non mettere mai un effetto collaterale dentro un assert. assert(read_next() > 0) nella build di rilascio smette del tutto di leggere, e il bug risultante compare solo in produzione.

Le asserzioni servono per i tuoi errori: condizioni che dovrebbero essere impossibili se il codice è corretto. Un input utente sbagliato non è un'asserzione; è un if con un messaggio di errore.

Il resto, in breve

• <stddef.h>: size_t, ptrdiff_t, NULL, offsetof
• <stdarg.h>: funzioni variadiche, il meccanismo dietro printf
• <errno.h>: errno più perror e strerror per riportare perché una chiamata è fallita
• <signal.h>: gestione dei segnali come Ctrl-C
• <setjmp.h>: salti non locali; raramente la risposta giusta
• <locale.h>, <wchar.h>, <wctype.h>: locale e caratteri estesi
• <stdnoreturn.h>, <stdalign.h>, <threads.h>, <stdatomic.h>: aggiunte del C11

Due abitudini rendono piacevole usare la libreria. Leggi la pagina di manuale prima di tirare a indovinare una firma: man 3 strtol su macOS e Linux è autorevole e veloce. E controlla i valori di ritorno: malloc, fopen e strtol segnalano tutti gli errori, e un programma che li ignora fallisce molto più tardi e in modo molto meno chiaro.