.. _reference_fonctions:

Fonctions du cours
==================

Cette page regroupe les fonctions présentées dans le cours, classées par en-tête (le fichier à inclure avec ``#include``). Chaque nom renvoie vers le bloc du cours qui donne sa signature, ses paramètres et sa valeur de retour.

La colonne **Norme** indique où la fonction est définie :

- **C** : bibliothèque standard du C, disponible partout (``aligned_alloc`` et les fonctions ``atomic_*`` datent de C11) ;
- **POSIX** : norme des systèmes de type Unix (Linux, macOS, BSD…) ;
- **Linux/BSD** : extension non portable, absente de la norme POSIX ;
- **macro** : macro qui s'utilise comme une fonction.

Le ``man`` reste la référence complète : section 2 pour les appels système (``man 2 open``), section 3 pour les fonctions de bibliothèque (``man 3 printf``). Quand un nom existe aussi comme commande, précisez la section : ``man printf`` affiche la commande du shell, ``man 3 printf`` la fonction C.

La dernière section, :ref:`fonctions_tp`, liste les fonctions utilisées dans les exercices sans être présentées dans le cours.

``<stdio.h>``
-------------

.. list-table::
    :header-rows: 1
    :widths: 25 50 10 15

    * - Fonction
      - Rôle
      - Norme
      - Chapitre
    * - :ref:`printf <fn_printf>`
      - Affiche un texte formaté sur la sortie standard.
      - C
      - :ref:`cours_c`
    * - :ref:`fprintf <fn_fprintf>`
      - Écrit un texte formaté dans un flux (``stderr``, fichier ouvert…).
      - C
      - :ref:`cours_c`
    * - :ref:`fflush <fn_fflush>`
      - Vide le buffer d'un flux.
      - C
      - :ref:`cours_c`
    * - :ref:`scanf <fn_scanf>`
      - Lit des valeurs formatées sur l'entrée standard.
      - C
      - :ref:`cours_c`
    * - :ref:`fgets <fn_fgets>`
      - Lit une ligne (de taille bornée) depuis un flux.
      - C
      - :ref:`cours_c`
    * - :ref:`perror <fn_perror>`
      - Affiche sur ``stderr`` un message suivi de la description de ``errno``.
      - C
      - :ref:`cours_c`
    * - :ref:`fopen <fn_fopen>`
      - Ouvre un fichier et retourne un flux ``FILE *``.
      - C
      - :ref:`cours_fichiers`
    * - :ref:`fclose <fn_fclose>`
      - Ferme un flux (après avoir vidé son buffer).
      - C
      - :ref:`cours_fichiers`
    * - :ref:`fdopen <fn_fdopen>`
      - Associe un flux ``FILE *`` à un descripteur déjà ouvert.
      - POSIX
      - :ref:`cours_processus`
    * - :ref:`setvbuf <fn_setvbuf>`
      - Choisit le mode de bufferisation d'un flux (par ligne, par bloc…).
      - C
      - :ref:`cours_processus`

Les fonctions suivantes n'ont pas de bloc détaillé : elles sont présentées dans le :ref:`tableau libc/POSIX <libc_posix>` du chapitre :ref:`cours_fichiers`.

.. list-table::
    :header-rows: 1
    :widths: 15 40 30 15

    * - Fonction
      - Signature
      - Rôle
      - Norme
    * - ``fread``
      - ``size_t fread(void *ptr, size_t size, size_t nmemb, FILE *stream);``
      - Lit des blocs d'octets depuis un flux.
      - C
    * - ``fwrite``
      - ``size_t fwrite(const void *ptr, size_t size, size_t nmemb, FILE *stream);``
      - Écrit des blocs d'octets dans un flux.
      - C
    * - ``fputs``
      - ``int fputs(const char *s, FILE *stream);``
      - Écrit une chaîne dans un flux (sans ajouter de ``\n``).
      - C
    * - ``getline``
      - ``ssize_t getline(char **lineptr, size_t *n, FILE *stream);``
      - Lit une ligne entière, en allouant le buffer dans la heap si besoin.
      - POSIX
    * - ``snprintf``
      - ``int snprintf(char *str, size_t size, const char *format, ...);``
      - Écrit un texte formaté dans une chaîne, sans dépasser sa taille.
      - C
    * - ``fseek``
      - ``int fseek(FILE *stream, long offset, int whence);``
      - Déplace la position de lecture/écriture d'un flux.
      - C

``<stdlib.h>``
--------------

.. list-table::
    :header-rows: 1
    :widths: 25 50 10 15

    * - Fonction
      - Rôle
      - Norme
      - Chapitre
    * - :ref:`atoi <fn_atoi>`
      - Convertit le début d'une chaîne en ``int`` (sans détection d'erreur).
      - C
      - :ref:`cours_c`
    * - :ref:`malloc <fn_malloc>`
      - Alloue une zone mémoire dans la heap.
      - C
      - :ref:`cours_c`
    * - :ref:`calloc <fn_calloc>`
      - Alloue un tableau dans la heap, initialisé à zéro.
      - C
      - :ref:`cours_c`
    * - :ref:`realloc <fn_realloc>`
      - Change la taille d'une zone allouée dans la heap.
      - C
      - :ref:`cours_c`
    * - :ref:`free <fn_free>`
      - Libère une zone allouée dans la heap.
      - C
      - :ref:`cours_c`
    * - :ref:`exit <fn_exit>`
      - Termine le programme après avoir vidé les buffers des flux.
      - C
      - :ref:`cours_c`
    * - :ref:`rand <fn_rand>`
      - Retourne un entier pseudo-aléatoire entre ``0`` et ``RAND_MAX``.
      - C
      - :ref:`cours_c`
    * - :ref:`srand <fn_srand>`
      - Initialise la graine utilisée par ``rand``.
      - C
      - :ref:`cours_c`
    * - :ref:`posix_memalign <fn_posix_memalign>`
      - Alloue dans la heap une zone dont l'adresse est alignée.
      - POSIX
      - :ref:`cours_memoire`
    * - :ref:`aligned_alloc <fn_aligned_alloc>`
      - Alloue dans la heap une zone dont l'adresse est alignée.
      - C
      - :ref:`cours_memoire`

``<string.h>``
--------------

.. list-table::
    :header-rows: 1
    :widths: 25 50 10 15

    * - Fonction
      - Rôle
      - Norme
      - Chapitre
    * - :ref:`strlen <fn_strlen>`
      - Retourne la longueur d'une chaîne (sans le ``\0``).
      - C
      - :ref:`cours_c`
    * - :ref:`strcpy <fn_strcpy>`
      - Copie une chaîne dans une autre.
      - C
      - :ref:`cours_c`
    * - :ref:`strncpy <fn_strncpy>`
      - Copie au plus ``n`` caractères d'une chaîne.
      - C
      - :ref:`cours_c`
    * - :ref:`strcat <fn_strcat>`
      - Ajoute une chaîne à la fin d'une autre.
      - C
      - :ref:`cours_c`
    * - :ref:`strcmp <fn_strcmp>`
      - Compare deux chaînes.
      - C
      - :ref:`cours_c`
    * - :ref:`strcspn <fn_strcspn>`
      - Retourne la position du premier caractère appartenant à un ensemble donné.
      - C
      - :ref:`cours_c`
    * - :ref:`memset <fn_memset>`
      - Remplit une zone mémoire avec un même octet.
      - C
      - :ref:`cours_c`
    * - :ref:`strerror <fn_strerror>`
      - Retourne la description d'un code d'erreur (``errno`` ou code pthread).
      - C
      - :ref:`cours_c`
    * - :ref:`strsignal <fn_strsignal>`
      - Retourne la description d'un numéro de signal.
      - POSIX
      - :ref:`cours_processus`

``<time.h>``
------------

.. list-table::
    :header-rows: 1
    :widths: 25 50 10 15

    * - Fonction
      - Rôle
      - Norme
      - Chapitre
    * - :ref:`time <fn_time>`
      - Retourne l'heure courante, en secondes depuis le 1er janvier 1970.
      - C
      - :ref:`cours_c`
    * - :ref:`clock <fn_clock>`
      - Retourne le temps CPU consommé par le programme.
      - C
      - :ref:`cours_memoire`

``<unistd.h>``
--------------

.. list-table::
    :header-rows: 1
    :widths: 25 50 10 15

    * - Fonction
      - Rôle
      - Norme
      - Chapitre
    * - :ref:`close <fn_close>`
      - Ferme un descripteur de fichier.
      - POSIX
      - :ref:`cours_fichiers`
    * - :ref:`write <fn_write>`
      - Écrit des octets sur un descripteur.
      - POSIX
      - :ref:`cours_fichiers`
    * - :ref:`read <fn_read>`
      - Lit des octets depuis un descripteur.
      - POSIX
      - :ref:`cours_fichiers`
    * - :ref:`lseek <fn_lseek>`
      - Déplace la position de lecture/écriture d'un descripteur.
      - POSIX
      - :ref:`cours_fichiers`
    * - :ref:`fork <fn_fork>`
      - Crée un processus enfant, copie du processus appelant.
      - POSIX
      - :ref:`cours_processus`
    * - :ref:`getpid <fn_getpid>`
      - Retourne le PID du processus appelant.
      - POSIX
      - :ref:`cours_processus`
    * - :ref:`getppid <fn_getppid>`
      - Retourne le PID du processus parent.
      - POSIX
      - :ref:`cours_processus`
    * - :ref:`execl <fn_execl>`
      - Remplace le programme du processus (chemin, arguments en liste).
      - POSIX
      - :ref:`cours_processus`
    * - :ref:`execlp <fn_execlp>`
      - Remplace le programme du processus (recherche dans le ``PATH``, arguments en liste).
      - POSIX
      - :ref:`cours_processus`
    * - :ref:`execv <fn_execv>`
      - Remplace le programme du processus (chemin, arguments en tableau).
      - POSIX
      - :ref:`cours_processus`
    * - :ref:`execvp <fn_execvp>`
      - Remplace le programme du processus (recherche dans le ``PATH``, arguments en tableau).
      - POSIX
      - :ref:`cours_processus`
    * - :ref:`execle <fn_execle>`
      - Comme ``execl``, avec un environnement fourni.
      - POSIX
      - :ref:`cours_processus`
    * - :ref:`execve <fn_execve>`
      - Comme ``execv``, avec un environnement fourni (l'appel système sous-jacent).
      - POSIX
      - :ref:`cours_processus`
    * - :ref:`execvpe <fn_execvpe>`
      - Comme ``execvp``, avec un environnement fourni.
      - Linux/BSD
      - :ref:`cours_processus`
    * - :ref:`fexecve <fn_fexecve>`
      - Comme ``execve``, le programme étant désigné par un descripteur.
      - POSIX
      - :ref:`cours_processus`
    * - :ref:`_exit <fn__exit>`
      - Termine le processus immédiatement, sans vider les buffers de la libc.
      - POSIX
      - :ref:`cours_processus`
    * - :ref:`pause <fn_pause>`
      - Suspend le processus jusqu'à la réception d'un signal.
      - POSIX
      - :ref:`cours_processus`
    * - :ref:`sleep <fn_sleep>`
      - Suspend le processus pendant un nombre de secondes.
      - POSIX
      - :ref:`cours_processus`
    * - :ref:`pipe <fn_pipe>`
      - Crée un pipe anonyme (un descripteur de lecture, un d'écriture).
      - POSIX
      - :ref:`cours_processus`
    * - :ref:`unlink <fn_unlink>`
      - Supprime un nom de fichier (fichier, FIFO…).
      - POSIX
      - :ref:`cours_processus`
    * - :ref:`gettid <fn_gettid>`
      - Retourne le TID du thread appelant (Linux uniquement).
      - Linux/BSD
      - :ref:`cours_threads`

``<fcntl.h>``
-------------

.. list-table::
    :header-rows: 1
    :widths: 25 50 10 15

    * - Fonction
      - Rôle
      - Norme
      - Chapitre
    * - :ref:`open <fn_open>`
      - Ouvre (ou crée) un fichier et retourne un descripteur.
      - POSIX
      - :ref:`cours_fichiers`

``<sys/stat.h>``
----------------

.. list-table::
    :header-rows: 1
    :widths: 25 50 10 15

    * - Fonction
      - Rôle
      - Norme
      - Chapitre
    * - :ref:`umask <fn_umask>`
      - Fixe le masque des droits retirés à la création des fichiers.
      - POSIX
      - :ref:`cours_fichiers`
    * - :ref:`mkfifo <fn_mkfifo>`
      - Crée un pipe nommé (FIFO).
      - POSIX
      - :ref:`cours_processus`

``<sys/file.h>``
----------------

.. list-table::
    :header-rows: 1
    :widths: 25 50 10 15

    * - Fonction
      - Rôle
      - Norme
      - Chapitre
    * - :ref:`flock <fn_flock>`
      - Pose ou retire un verrou sur un fichier ouvert.
      - Linux/BSD
      - :ref:`cours_fichiers`

``<sys/wait.h>``
----------------

.. list-table::
    :header-rows: 1
    :widths: 25 50 10 15

    * - Fonction
      - Rôle
      - Norme
      - Chapitre
    * - :ref:`wait <fn_wait>`
      - Attend la fin d'un enfant quelconque.
      - POSIX
      - :ref:`cours_processus`
    * - :ref:`waitpid <fn_waitpid>`
      - Attend la fin d'un enfant donné (sans bloquer avec ``WNOHANG``).
      - POSIX
      - :ref:`cours_processus`
    * - :ref:`WIFEXITED <fn_wifexited>`
      - Indique si l'enfant s'est terminé normalement.
      - macro
      - :ref:`cours_processus`
    * - :ref:`WEXITSTATUS <fn_wexitstatus>`
      - Donne le code de retour de l'enfant.
      - macro
      - :ref:`cours_processus`
    * - :ref:`WIFSIGNALED <fn_wifsignaled>`
      - Indique si l'enfant a été tué par un signal.
      - macro
      - :ref:`cours_processus`
    * - :ref:`WTERMSIG <fn_wtermsig>`
      - Donne le numéro du signal qui a tué l'enfant.
      - macro
      - :ref:`cours_processus`

``<signal.h>``
--------------

.. list-table::
    :header-rows: 1
    :widths: 25 50 10 15

    * - Fonction
      - Rôle
      - Norme
      - Chapitre
    * - :ref:`kill <fn_kill>`
      - Envoie un signal à un processus.
      - POSIX
      - :ref:`cours_processus`
    * - :ref:`sigaction <fn_sigaction>`
      - Choisit la réaction à un signal (gestionnaire, ignorer…).
      - POSIX
      - :ref:`cours_processus`
    * - :ref:`sigemptyset <fn_sigemptyset>`
      - Vide un ensemble de signaux.
      - POSIX
      - :ref:`cours_processus`
    * - :ref:`sigaddset <fn_sigaddset>`
      - Ajoute un signal à un ensemble.
      - POSIX
      - :ref:`cours_processus`
    * - :ref:`sigdelset <fn_sigdelset>`
      - Retire un signal d'un ensemble.
      - POSIX
      - :ref:`cours_processus`
    * - :ref:`sigismember <fn_sigismember>`
      - Teste si un signal fait partie d'un ensemble.
      - POSIX
      - :ref:`cours_processus`

``<pthread.h>``
---------------

.. list-table::
    :header-rows: 1
    :widths: 25 50 10 15

    * - Fonction
      - Rôle
      - Norme
      - Chapitre
    * - :ref:`pthread_create <fn_pthread_create>`
      - Crée un thread qui exécute une fonction.
      - POSIX
      - :ref:`cours_threads`
    * - :ref:`pthread_join <fn_pthread_join>`
      - Attend la fin d'un thread et récupère sa valeur de retour.
      - POSIX
      - :ref:`cours_threads`
    * - :ref:`pthread_exit <fn_pthread_exit>`
      - Termine le thread appelant.
      - POSIX
      - :ref:`cours_threads`
    * - :ref:`pthread_detach <fn_pthread_detach>`
      - Détache un thread : ses ressources sont libérées à sa fin, sans ``pthread_join``.
      - POSIX
      - :ref:`cours_threads`
    * - :ref:`pthread_attr_init <fn_pthread_attr_init>`
      - Initialise un objet d'attributs de thread.
      - POSIX
      - :ref:`cours_threads`
    * - :ref:`pthread_attr_setdetachstate <fn_pthread_attr_setdetachstate>`
      - Choisit dans les attributs si le thread sera créé détaché.
      - POSIX
      - :ref:`cours_threads`
    * - :ref:`pthread_attr_destroy <fn_pthread_attr_destroy>`
      - Détruit un objet d'attributs de thread.
      - POSIX
      - :ref:`cours_threads`
    * - :ref:`pthread_mutex_init <fn_pthread_mutex_init>`
      - Initialise un mutex.
      - POSIX
      - :ref:`cours_threads`
    * - :ref:`pthread_mutex_destroy <fn_pthread_mutex_destroy>`
      - Détruit un mutex.
      - POSIX
      - :ref:`cours_threads`
    * - :ref:`pthread_mutex_lock <fn_pthread_mutex_lock>`
      - Verrouille un mutex (attend s'il est déjà verrouillé).
      - POSIX
      - :ref:`cours_threads`
    * - :ref:`pthread_mutex_unlock <fn_pthread_mutex_unlock>`
      - Déverrouille un mutex.
      - POSIX
      - :ref:`cours_threads`
    * - :ref:`pthread_cond_wait <fn_pthread_cond_wait>`
      - Libère le mutex et attend un signal sur la variable de condition.
      - POSIX
      - :ref:`cours_threads`
    * - :ref:`pthread_cond_signal <fn_pthread_cond_signal>`
      - Réveille un thread en attente sur la variable de condition.
      - POSIX
      - :ref:`cours_threads`
    * - :ref:`pthread_cond_broadcast <fn_pthread_cond_broadcast>`
      - Réveille tous les threads en attente sur la variable de condition.
      - POSIX
      - :ref:`cours_threads`
    * - :ref:`pthread_cond_init <fn_pthread_cond_init>`
      - Initialise une variable de condition.
      - POSIX
      - :ref:`cours_threads`
    * - :ref:`pthread_cond_destroy <fn_pthread_cond_destroy>`
      - Détruit une variable de condition.
      - POSIX
      - :ref:`cours_threads`

``<stdatomic.h>``
-----------------

.. list-table::
    :header-rows: 1
    :widths: 25 50 10 15

    * - Fonction
      - Rôle
      - Norme
      - Chapitre
    * - :ref:`atomic_load <fn_atomic_load>`
      - Lit une variable atomique.
      - C
      - :ref:`cours_threads`
    * - :ref:`atomic_store <fn_atomic_store>`
      - Écrit dans une variable atomique.
      - C
      - :ref:`cours_threads`
    * - :ref:`atomic_fetch_add <fn_atomic_fetch_add>`
      - Ajoute une valeur à une variable atomique et retourne l'ancienne valeur.
      - C
      - :ref:`cours_threads`
    * - :ref:`atomic_fetch_sub <fn_atomic_fetch_sub>`
      - Soustrait une valeur à une variable atomique et retourne l'ancienne valeur.
      - C
      - :ref:`cours_threads`

``<sys/socket.h>``
------------------

.. list-table::
    :header-rows: 1
    :widths: 25 50 10 15

    * - Fonction
      - Rôle
      - Norme
      - Chapitre
    * - :ref:`socket <fn_socket>`
      - Crée un socket et retourne son descripteur.
      - POSIX
      - :ref:`cours_sockets`
    * - :ref:`setsockopt <fn_setsockopt>`
      - Modifie une option d'un socket (par exemple ``SO_REUSEADDR``).
      - POSIX
      - :ref:`cours_sockets`
    * - :ref:`bind <fn_bind>`
      - Associe une adresse (IP et port) à un socket.
      - POSIX
      - :ref:`cours_sockets`
    * - :ref:`listen <fn_listen>`
      - Met un socket TCP en écoute des connexions entrantes.
      - POSIX
      - :ref:`cours_sockets`
    * - :ref:`accept <fn_accept>`
      - Accepte une connexion et retourne un nouveau descripteur pour ce client.
      - POSIX
      - :ref:`cours_sockets`
    * - :ref:`connect <fn_connect>`
      - Connecte un socket à une adresse distante.
      - POSIX
      - :ref:`cours_sockets`
    * - :ref:`send <fn_send>`
      - Envoie des octets sur un socket connecté.
      - POSIX
      - :ref:`cours_sockets`
    * - :ref:`recv <fn_recv>`
      - Reçoit des octets sur un socket connecté.
      - POSIX
      - :ref:`cours_sockets`
    * - :ref:`sendto <fn_sendto>`
      - Envoie un datagramme à une adresse donnée (UDP).
      - POSIX
      - :ref:`cours_sockets`
    * - :ref:`recvfrom <fn_recvfrom>`
      - Reçoit un datagramme et l'adresse de son expéditeur (UDP).
      - POSIX
      - :ref:`cours_sockets`
    * - :ref:`shutdown <fn_shutdown>`
      - Ferme un sens de la communication, ou les deux.
      - POSIX
      - :ref:`cours_sockets`

``<arpa/inet.h>``
-----------------

.. list-table::
    :header-rows: 1
    :widths: 25 50 10 15

    * - Fonction
      - Rôle
      - Norme
      - Chapitre
    * - :ref:`htons <fn_htons>`
      - Convertit un entier 16 bits de l'ordre de l'hôte vers l'ordre réseau.
      - POSIX
      - :ref:`cours_sockets`
    * - :ref:`htonl <fn_htonl>`
      - Convertit un entier 32 bits de l'ordre de l'hôte vers l'ordre réseau.
      - POSIX
      - :ref:`cours_sockets`
    * - :ref:`ntohs <fn_ntohs>`
      - Convertit un entier 16 bits de l'ordre réseau vers l'ordre de l'hôte.
      - POSIX
      - :ref:`cours_sockets`
    * - :ref:`ntohl <fn_ntohl>`
      - Convertit un entier 32 bits de l'ordre réseau vers l'ordre de l'hôte.
      - POSIX
      - :ref:`cours_sockets`
    * - :ref:`inet_pton <fn_inet_pton>`
      - Convertit une adresse IP écrite en texte vers sa forme binaire.
      - POSIX
      - :ref:`cours_sockets`
    * - :ref:`inet_ntop <fn_inet_ntop>`
      - Convertit une adresse IP binaire en texte.
      - POSIX
      - :ref:`cours_sockets`

.. _fonctions_tp:

Fonctions vues en TP
--------------------

Ces fonctions sont utilisées dans les exercices (énoncés ou corrections) mais ne sont pas présentées dans le cours. La colonne **Exercice** renvoie vers les exercices où elles apparaissent ; consultez leur page de ``man`` pour le détail.

``<stdio.h>``
~~~~~~~~~~~~~

.. list-table::
    :header-rows: 1
    :widths: 15 40 30 15

    * - Fonction
      - Signature
      - Rôle
      - Exercice
    * - ``puts``
      - ``int puts(const char *s);``
      - Affiche une chaîne suivie d'un ``\n`` sur la sortie standard.
      - :ref:`p1e6 <exo_p1e6>`, :ref:`p3e3 <exo_p3e3>`
    * - ``getchar``
      - ``int getchar(void);``
      - Lit un caractère sur l'entrée standard.
      - :ref:`p3e6 <exo_p3e6>`
    * - ``feof``
      - ``int feof(FILE *stream);``
      - Indique si la fin de fichier a été atteinte sur un flux.
      - :ref:`p2e8 <exo_p2e8>`, :ref:`p4e6 <exo_p4e6>`
    * - ``ferror``
      - ``int ferror(FILE *stream);``
      - Indique si une erreur s'est produite sur un flux.
      - :ref:`p2e8 <exo_p2e8>`, :ref:`p2e9 <exo_p2e9>`, :ref:`p6e2 <exo_p6e2>`
    * - ``rename``
      - ``int rename(const char *oldpath, const char *newpath);``
      - Renomme (ou déplace) un fichier.
      - :ref:`p2e6 <exo_p2e6>`

``<stdlib.h>``
~~~~~~~~~~~~~~

.. list-table::
    :header-rows: 1
    :widths: 15 40 30 15

    * - Fonction
      - Signature
      - Rôle
      - Exercice
    * - ``strtol``
      - ``long strtol(const char *nptr, char **endptr, int base);``
      - Convertit une chaîne en ``long``, en détectant les erreurs.
      - :ref:`p2e9 <exo_p2e9>`, :ref:`p2e10 <exo_p2e10>`
    * - ``atol``
      - ``long atol(const char *nptr);``
      - Convertit une chaîne en ``long`` (sans détection d'erreur).
      - :ref:`p5 (introduction) <exo_threads>`
    * - ``atoll``
      - ``long long atoll(const char *nptr);``
      - Convertit une chaîne en ``long long`` (sans détection d'erreur).
      - :ref:`p5 (introduction) <exo_threads>`, :ref:`p5e9 <exo_p5e9>`
    * - ``strtoul``
      - ``unsigned long strtoul(const char *nptr, char **endptr, int base);``
      - Convertit une chaîne en ``unsigned long``, en détectant les erreurs.
      - :ref:`p5 (introduction) <exo_threads>`
    * - ``strtoull``
      - ``unsigned long long strtoull(const char *nptr, char **endptr, int base);``
      - Convertit une chaîne en ``unsigned long long``, en détectant les erreurs.
      - :ref:`p5 (introduction) <exo_threads>`, :ref:`p5e3 <exo_p5e3>`, :ref:`p5e9 <exo_p5e9>`
    * - ``rand_r``
      - ``int rand_r(unsigned int *seedp);``
      - Comme ``rand``, avec une graine fournie par l'appelant (utilisable par plusieurs threads).
      - :ref:`p5e8 <exo_p5e8>`

``<string.h>``
~~~~~~~~~~~~~~

.. list-table::
    :header-rows: 1
    :widths: 15 40 30 15

    * - Fonction
      - Signature
      - Rôle
      - Exercice
    * - ``strncmp``
      - ``int strncmp(const char *s1, const char *s2, size_t n);``
      - Compare au plus les ``n`` premiers caractères de deux chaînes.
      - :ref:`p6e3 <exo_p6e3>`, :ref:`p6e4 <exo_p6e4>`, :ref:`p6e5 <exo_p6e5>`, :ref:`p6e6 <exo_p6e6>`
    * - ``strchr``
      - ``char *strchr(const char *s, int c);``
      - Cherche la première occurrence d'un caractère dans une chaîne.
      - :ref:`p6e4 <exo_p6e4>`, :ref:`p6e5 <exo_p6e5>`, :ref:`p6e6 <exo_p6e6>`
    * - ``strtok``
      - ``char *strtok(char *str, const char *delim);``
      - Découpe une chaîne en morceaux selon des séparateurs (la chaîne est modifiée).
      - :ref:`p4e8 <exo_p4e8>`

``<ctype.h>``
~~~~~~~~~~~~~

.. list-table::
    :header-rows: 1
    :widths: 15 40 30 15

    * - Fonction
      - Signature
      - Rôle
      - Exercice
    * - ``toupper``
      - ``int toupper(int c);``
      - Convertit un caractère en majuscule.
      - :ref:`p6e3 <exo_p6e3>`
    * - ``tolower``
      - ``int tolower(int c);``
      - Convertit un caractère en minuscule.
      - :ref:`p6e3 <exo_p6e3>`

``<time.h>``
~~~~~~~~~~~~

.. list-table::
    :header-rows: 1
    :widths: 15 40 30 15

    * - Fonction
      - Signature
      - Rôle
      - Exercice
    * - ``clock_gettime``
      - ``int clock_gettime(clockid_t clockid, struct timespec *tp);``
      - Lit une horloge (par exemple ``CLOCK_MONOTONIC``) à la nanoseconde près.
      - :ref:`p5 (introduction) <exo_threads>`, :ref:`p5e9 <exo_p5e9>`
    * - ``ctime``
      - ``char *ctime(const time_t *timep);``
      - Convertit un ``time_t`` en date lisible (chaîne terminée par ``\n``).
      - :ref:`p6e3 <exo_p6e3>`
    * - ``ctime_r``
      - ``char *ctime_r(const time_t *timep, char *buf);``
      - Comme ``ctime``, dans un buffer fourni par l'appelant (utilisable par plusieurs threads).
      - :ref:`p6e4 <exo_p6e4>`
    * - ``localtime``
      - ``struct tm *localtime(const time_t *timep);``
      - Décompose un ``time_t`` en ``struct tm`` (heure locale).
      - :ref:`p6e6 <exo_p6e6>`
    * - ``localtime_r``
      - ``struct tm *localtime_r(const time_t *timep, struct tm *result);``
      - Comme ``localtime``, dans une structure fournie par l'appelant (utilisable par plusieurs threads).
      - :ref:`p6e6 <exo_p6e6>`
    * - ``strftime``
      - ``size_t strftime(char *s, size_t max, const char *format, const struct tm *tm);``
      - Écrit une date (``struct tm``) dans une chaîne selon un format.
      - :ref:`p6e6 <exo_p6e6>`
    * - ``nanosleep``
      - ``int nanosleep(const struct timespec *req, struct timespec *rem);``
      - Suspend le thread pendant une durée précise (secondes et nanosecondes).
      - :ref:`p5e8 <exo_p5e8>`

``<sys/stat.h>``
~~~~~~~~~~~~~~~~

.. list-table::
    :header-rows: 1
    :widths: 15 40 30 15

    * - Fonction
      - Signature
      - Rôle
      - Exercice
    * - ``mkdir``
      - ``int mkdir(const char *pathname, mode_t mode);``
      - Crée un répertoire.
      - :ref:`p2e10 <exo_p2e10>`

``<unistd.h>``
~~~~~~~~~~~~~~

.. list-table::
    :header-rows: 1
    :widths: 15 40 30 15

    * - Fonction
      - Signature
      - Rôle
      - Exercice
    * - ``access``
      - ``int access(const char *pathname, int mode);``
      - Teste l'existence d'un fichier ou les droits du processus sur ce fichier.
      - :ref:`p2e6 <exo_p2e6>`
    * - ``link``
      - ``int link(const char *oldpath, const char *newpath);``
      - Crée un lien physique vers un fichier.
      - :ref:`p2e10 <exo_p2e10>`
    * - ``symlink``
      - ``int symlink(const char *target, const char *linkpath);``
      - Crée un lien symbolique vers un fichier.
      - :ref:`p2e10 <exo_p2e10>`
    * - ``chdir``
      - ``int chdir(const char *path);``
      - Change le répertoire courant du processus.
      - :ref:`p4e8 <exo_p4e8>`