La bibliothèque standard du C : une carte des en-têtes à connaître

Le C, en tant que langage, est minuscule - types, opérateurs, flux de contrôle, fonctions, pointeurs. Il ne peut ni afficher, ni lire un fichier, ni comparer une chaîne, ni allouer de la mémoire. Tout cela, c'est la bibliothèque standard : un ensemble d'en-têtes que toute implémentation conforme livre.

Cette page est une carte. Chaque section dit à quoi sert un en-tête, montre un court exemple fonctionnel, et pointe vers la page plus complète quand elle existe.

stdio.h - l'entrée et la sortie

L'en-tête que vous incluez en premier dans presque tout programme. Il contient printf et scanf, le type FILE et les fonctions de fichiers, et les fonctions d'entrée orientées ligne, plus sûres.

#include <stdio.h>

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

    /* fputs ecrit sans interpreter les specificateurs de format */
    fputs("Sortie simple, sans mise en forme\n", stdout);

    /* stderr est un flux distinct pour les diagnostics */
    fprintf(stderr, "Ceci va vers la sortie d'erreur\n");

    /* putchar ecrit un seul caractere */
    for (char c = 'a'; c <= 'e'; c++) {
        putchar(c);
    }
    putchar('\n');
    return 0;
}

L'essentiel : printf, fprintf, sprintf, snprintf pour la sortie ; scanf, fscanf, sscanf, fgets, getchar pour l'entrée ; fopen, fclose, fread, fwrite, fseek pour les fichiers. Une couverture plus approfondie se trouve dans printf, scanf et les fichiers.

Une règle à emporter : n'utilisez jamais gets(). Elle n'a aucun moyen de connaître la taille de votre tampon et a été retirée de la norme en C11. fgets(buf, sizeof buf, stdin) en est le remplacement.

stdlib.h - les utilitaires généraux

Le fourre-tout : mémoire, conversions, aléa, contrôle du processus, tri.

#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) {
    /* chaine vers nombre */
    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"));

    /* memoire dynamique */
    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 trie n'importe quoi avec une fonction de comparaison */
    qsort(nums, 5, sizeof *nums, compare_ints);
    for (int i = 0; i < 5; i++) {
        printf("%d ", nums[i]);
    }
    printf("\n");

    free(nums);
    return 0;
}

À retenir : malloc, calloc, realloc, free (voir mémoire dynamique) ; atoi, atof, strtol, strtod pour les conversions - préférez la famille strto*, qui peut signaler l'échec là où atoi renvoie silencieusement 0 ; rand et srand (voir nombres aléatoires) ; exit, abort, getenv, system ; et qsort/bsearch.

string.h - chaînes et blocs de mémoire

Les chaînes C sont des tableaux de char se terminant par '\0', et chaque opération sur elles est un appel de fonction.

#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);

    /* les fonctions mem* travaillent sur des octets bruts, pas seulement du texte */
    char block[10];
    memset(block, '-', 9);
    block[9] = '\0';
    printf("memset  : %s\n", block);
    return 0;
}

Deux habitudes empêchent cet en-tête de devenir une source de débordements de tampon : connaissez toujours la taille de la destination, et rappelez-vous que strcmp renvoie 0 pour l'égalité - if (strcmp(a, b)) est vrai quand les chaînes diffèrent. Les fonctions de chaînes couvrent en détail les motifs plus sûrs strncpy/snprintf.

math.h - les mathématiques

sqrt, pow, fabs, floor, ceil, round, fmod, les familles trigonométriques et logarithmiques, INFINITY et 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;
}

C'est le seul en-tête qui peut demander une option d'édition de liens : sous Linux, ajoutez -lm à la fin de la commande de compilation, sinon l'éditeur de liens signale « undefined reference to sqrt ». Tour complet dans les fonctions mathématiques.

time.h - horloges et dates

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

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

    struct tm *lt = localtime(&now);
    printf("Annee : %d, mois : %d, jour : %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("Formate : %s\n", buf);

    /* clock() mesure le temps processeur utilise par ce programme */
    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("La boucle a pris %.4f secondes CPU\n", secs);
    return 0;
}

Les deux décalages de struct tm piègent tout le monde : tm_year compte à partir de 1900, et tm_mon commence à 0. time(NULL) est aussi la graine habituelle de srand.

ctype.h - la classification des caractères

Petit, et plus utile qu'il n'en a l'air. Chaque fonction prend un caractère et répond à une question oui/non, ou convertit la casse.

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

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

    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("lettres=%d chiffres=%d espaces=%d ponctuation=%d\n",
           letters, digits, spaces, punct);

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

L'ensemble complet : isalpha, isdigit, isalnum, isspace, isupper, islower, ispunct, isxdigit, isprint, plus toupper et tolower.

Remarquez le cast (unsigned char). Ces fonctions sont définies pour les valeurs représentables en unsigned char plus EOF ; un char simple est signé sur la plupart des systèmes, donc un octet au-dessus de 127 arrive comme un nombre négatif et l'appel devient un comportement indéfini. Le cast ne coûte rien et supprime toute la classe de problème.

Et préférez-les aux tests écrits à la main. c >= '0' && c <= '9' fonctionne par hasard, mais isdigit(c) dit ce que vous voulez dire et reste correct partout.

limits.h et float.h - les bornes des types

Jusqu'où peut aller un int sur cette machine ? Ces en-têtes y répondent, et ces réponses expliquent pourquoi le code portable demande au lieu de supposer.

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

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

    printf("float  : %g a %g (%zu octets)\n", FLT_MIN, FLT_MAX, sizeof(float));
    printf("double : %g a %g (%zu octets)\n", DBL_MIN, DBL_MAX, sizeof(double));
    printf("double a %d chiffres decimaux de precision\n", DBL_DIG);
    return 0;
}

INT_MAX est la façon de tester un débordement avant qu'il n'arrive, ce qui compte puisque le débordement signé est un comportement indéfini et non un rebouclage testable après coup.

stdbool.h et stdint.h - de meilleurs types

Le C n'avait pas de type booléen avant C99. <stdbool.h> en fournit un :

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

bool, true et false sont des macros pour _Bool, 1 et 0, mais elles rendent l'intention évidente. (En C23, ils sont devenus des mots-clés et l'en-tête n'est plus nécessaire.)

<stdint.h> donne des types de largeurs garanties - essentiel pour les formats de fichiers, les protocoles réseau et tout l'embarqué, où « un int fait probablement 32 bits » ne suffit pas :

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

Les macros du style PRId32 de <inttypes.h> se développent en le bon spécificateur printf pour chaque type de largeur fixe sur la plateforme courante - c'est la façon portable de les afficher, puisque %d convient pour int32_t sur certains systèmes et pas sur d'autres.

assert.h - vérifier vos hypothèses

assert(expr) ne fait rien quand l'expression est vraie et abandonne le programme avec un message quand elle est fausse.

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

int divide(int a, int b) {
    assert(b != 0);          /* un contrat : les appelants ne doivent pas passer 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) ici abandonnerait avec :
       Assertion `b != 0' failed. */
    return 0;
}

Compiler avec -DNDEBUG supprime chaque assertion, elles ne coûtent donc rien dans une version de production. C'est aussi l'avertissement : ne mettez jamais d'effet de bord dans un assert. assert(read_next() > 0) arrête complètement la lecture dans la version de production, et le bug qui en résulte n'apparaît qu'en production.

Les assertions sont pour vos erreurs - des conditions qui devraient être impossibles si le code est correct. Une mauvaise saisie utilisateur n'est pas une assertion ; c'est un if et un message d'erreur.

Le reste, brièvement

• <stddef.h> - size_t, ptrdiff_t, NULL, offsetof
• <stdarg.h> - les fonctions variadiques, la machinerie derrière printf
• <errno.h> - errno plus perror et strerror pour signaler pourquoi un appel a échoué
• <signal.h> - la gestion des signaux comme Ctrl-C
• <setjmp.h> - les sauts non locaux ; rarement la bonne réponse
• <locale.h>, <wchar.h>, <wctype.h> - locales et caractères larges
• <stdnoreturn.h>, <stdalign.h>, <threads.h>, <stdatomic.h> - les ajouts de C11

Deux habitudes rendent la bibliothèque agréable à utiliser. Lisez la page de manuel avant de deviner une signature - man 3 strtol sous macOS et Linux fait autorité et va vite. Et vérifiez les valeurs de retour : malloc, fopen et strtol signalent tous l'échec, et un programme qui les ignore échoue bien plus tard et bien moins clairement.