%title          Définitions standards du C
%comment        Liste des fonctions et définitions standards de la bibliothèque C.
%keywords       prog/index
%id             $Id: libc-standard.text,v 1.8 2008/05/18 08:06:58 minh Exp minh $
%copyright      Copyright (c) 2008 Nhat Minh Lê


%tableofcontents


= Où obtenir de la documentation sur les fonctions de la bibliothèque
  standard ?    [ou]

La source idéale serait la norme, bien évidemment, mais elle n'est
certainement pas le document le plus accessible qui soit. Pour les
courageux, sachez qu'une version brouillon est disponible sur le site
du [groupe de standardisation travaillant sur le langage C][wg14].

 [wg14] http://www.open-std.org/jtc1/sc22/wg14/

Dans le cas contraire, vous pouvez également trouver de la
documentation peut-être plus accessibles...

== Sur votre système    [sursys]

Un autre moyen de vous procurer de la bonne documentation est de lire
celle correspondant à votre système.

Sous un système de type Unix, cela signifie lire la page de manuel
(+man page+(en)) grâce à la commande :

  $ man NOM_DE_LA_FONCTION

Si vous utilisez un système GNU, les pages info sont également
disponibles :

  $ info NOM_DE_LA_FONCTION

Sous Windows, si vous avez Visual Studio ou le Platform
.SDK. installé, vous devriez avoir accès à un fichier d'aide en
.HTML. compilé (`.chm`) que vous pouvez ouvrir depuis l'interface de
Visual Studio. Il comporte normalement un index et une recherche.

== Sur le +web+(en)     [surweb]

Vous trouverez beaucoup de pages de manuel sur la toile. Il vous
suffit de faire une recherche du type :

  man NOM_DE_LA_FONCTION SYSTÈME

N'oubliez pas de préciser votre système sous peine de tomber sur des
pages qui ne sont pas adaptées. Cela ne fonctionne évidemment que si
vous êtes sous un unixoïde.

À noter que le site Developpez.com propose [les pages de manuel de
Linux en français](http://man.developpez.com/). Les projets
.BSD. possèdent chacun leur propre site dédié disposant d'une section
pour les pages de manuel, [sur NetBSD.org](http://man.netbsd.org/),
par exemple, si vous utilisez NetBSD.

En ce qui concerne Windows, enfin, la .MSDN. est une source
d'information très complète. Il vous faudra trouver la page
correspondant à la bibliothèque C standard. Pour cela, recherchez les
termes +C Run-Time Library+(en), ou simplement .CRT., accompagnés du
nom de la fonction.


= Contenu de la bibliothèque standard   [cont]

La première colonne correspond au type d'usage que l'on fait de
l'entité dont le nom figure en deuxième colonne : T correspond
à /type/, C à /constante/, V à /valeur/, F à /fonction/ et
M à /macro/. Je parle là d'/usage/ : les constantes sont en vérité
définies comme des macros, et certaines fonctions peuvent l'être
également. La distinction principale entre une fonction et une
«~macro~» telle que j'emploie le terme ici est qu'il faut faire
attention à ne /pas/ inclure d'effet de bord dans les expressions
passées en arguments à une macro, celle-ci pouvant les évaluer
plusieurs fois, ce qui serait inattendu et incontrôlable, donc
catastrophique.

== Définitions usuelles (`<stddef.h>`) [stddef]

|T| `ptrdiff_t` | différence (en octets) de deux pointeurs
|T| `size_t`    | taille d'objets contigus en mémoire
|T| `wchar_t`   | caractère étendu (/souvent/, Unicode)
|C| `NULL`      | constante de pointeur nul
|M| `offsetof`  | position (en octets) d'un membre dans une structure


== Capacité des types entiers (`<limits.h>`)    [limits]

|C| `CHAR_BIT`  | nombre de bits dans un octet
|C| `SCHAR_MIN` | valeur minimale d'un `signed char` (-127~ou~moins)
|C| `SCHAR_MAX` | valeur maximale d'un `signed char` (127~ou~plus)
|C| `UCHAR_MAX` | valeur maximale d'un `unsigned char` (255~ou~plus)
|C| `CHAR_MIN`  | valeur minimale d'un `char` ; vaut `SCHAR_MIN` ou 0
|C| `CHAR_MAX`  | valeur maximale d'un `char` ; vaut `SCHAR_MAX` ou `UCHAR_MAX`
|C| `SHRT_MIN`  | valeur minimale d'un `short` (-32767~ou~moins)
|C| `SHRT_MAX`  | valeur maximale d'un `short` (32767~ou~plus)
|C| `USHRT_MAX` | valeur maximale d'un `unsigned short` (65535~ou~plus)
|C| `INT_MIN`   | valeur minimale d'un `int` (-32767~ou~moins)
|C| `INT_MAX`   | valeur maximale d'un `int` (32767~ou~plus)
|C| `UINT_MAX`  | valeur maximale d'un `unsigned int` (65535~ou~plus)
|C| `LONG_MIN`  | valeur minimale d'un `long` (-2147483647~ou~moins)
|C| `LONG_MAX`  | valeur maximale d'un `long` (2147483647~ou~plus)
|C| `ULONG_MAX` | valeur maximale d'un `unsigned long` (4294967295~ou~plus)
|C| `MB_LEN_MAX`| nombre maximal d'octets par caractère polyoctet


== Propriétés des types flottants (`<float.h>`) [float]

|C| `FLT_RADIX`     | base de l'exposant (2~ou~plus)
|C| `FLT_MANT_DIG`  |
  nombre de chiffres significatifs en base `FLT_RADIX` d'un `float`
|C| `FLT_MIN_EXP`   | exposant minimal en base `FLT_RADIX` d'un `float`
|C| `FLT_MAX_EXP`   | exposant maximal en base `FLT_RADIX` d'un `float`
|C| `FLT_DIG`       |
  nombre de chiffres significatifs en base 10 d'un `float` (6~ou~plus)
|C| `FLT_MIN_10_EXP`| exposant minimal en base 10 d'un `float` (-37~ou~moins)
|C| `FLT_MAX_10_EXP`| exposant minimal en base 10 d'un `float` (37~ou~moins)
|C| `FLT_EPSILON`   |
  différence entre 1 et le `float` supérieur le plus proche (1e-5~ou~moins)
|C| `FLT_MIN`       | valeur absolue minimale d'un `float` (1e-37~ou~moins)
|C| `FLT_MAX`       | valeur absolue maximale d'un `float` (1e37~ou~plus)

|C| `DBL_MANT_DIG`  | nombre de chiffres significatifs en base `FLT_RADIX`
  d'un `double`
|C| `DBL_MIN_EXP`   | exposant minimal en base `FLT_RADIX` d'un `double`
|C| `DBL_MAX_EXP`   | exposant maximal en base `FLT_RADIX` d'un `double`
|C| `DBL_DIG`       |
  nombre de chiffres significatifs en base 10 d'un `double` (10~ou~plus)
|C| `DBL_MIN_10_EXP`|
  exposant minimal en base 10 d'un `double` (-37~ou~moins)
|C| `DBL_MAX_10_EXP`|
  exposant minimal en base 10 d'un `double` (37~ou~moins)
|C| `DBL_EPSILON`   |
  différence entre 1 et le `double` supérieur le plus proche (1e-5~ou~moins)
|C| `DBL_MIN`       | valeur absolue minimale d'un `double` (1e-37~ou~moins)
|C| `DBL_MAX`       | valeur absolue maximale d'un `double` (1e37~ou~plus)

|C| `LDBL_MANT_DIG`  |
  nombre de chiffres significatifs en base `FLT_RADIX` d'un `long double`
|C| `LDBL_MIN_EXP`   |
  exposant minimal en base `FLT_RADIX` d'un `long double`
|C| `LDBL_MAX_EXP`   |
  exposant maximal en base `FLT_RADIX` d'un `long double`
|C| `LDBL_DIG`       |
  nombre de chiffres significatifs en base 10 d'un `long double` (10~ou~plus)
|C| `LDBL_MIN_10_EXP`|
  exposant minimal en base 10 d'un `long double` (-37~ou~moins)
|C| `LDBL_MAX_10_EXP`|
  exposant minimal en base 10 d'un `long double` (37~ou~moins)
|C| `LDBL_EPSILON`   |
  différence entre 1 et le `long double` supérieur le plus proche
  (1e-9~ou~moins)
|C| `LDBL_MIN`       |
  valeur absolue minimale d'un `long double` (1e-37~ou~moins)
|C| `LDBL_MAX`       |
  valeur absolue maximale d'un `long double` (1e37~ou~plus)


== Opérations sur les chaînes de caractères (`<string.h>`)     [string]

=== Opérations sur les zones de mémoire        [mem]

|F| `memset`    | remplit une zone de mémoire par répétition d'un octet
|F| `memcpy`    | copie un zone de mémoire dans une zone disjointe
|F| `memmove`   | copie un zone de mémoire dans une autre
|F| `memcmp`    | compare une zone de mémoire à une autre
|F| `memchr`    | première occurrence d'un octet dans une zone

=== Opérations sur les chaînes [str]

|F| `strlen`   | longueur d'une chaîne
|F| `strcpy`   | copie une chaîne dans une zone de mémoire
|F| `strncpy`  | copie une chaîne limitée en longueur dans une zone de mémoire
|F| `strcat`   | concatène une chaîne à la suite d'une autre
|F| `strncat`  | concatène une chaîne limitée en longueur à la suite d'une autre
|F| `strcmp`   | compare deux chaînes
|F| `strncmp`  | compare deux chaînes limitées en longueur
|F| `strcoll`  | compare deux chaînes en tenant compte des paramètres régionaux
|F| `strxfrm`  | met une chaîne sous une forme «~normale~»
|F| `strchr`   | première occurrence d'un caractère dans une chaîne
|F| `strrchr`  | dernière occurrence d'un caractère dans une chaîne
|F| `strpbrk`  | première occurrence d'un caractère
  d'un ensemble de caractères donné
|F| `strspn`   | longueur du préfixe maximal constitué de caractères
  d'un ensemble de caractères donné
|F| `strcspn`  | longueur du préfixe maximal sans caractère
  d'un ensemble de caractères donné
|F| `strstr`   | première occurrence d'une chaîne dans une autre
|F| `strtok`   | découpage d'une chaîne à chaque caractères d'un ensemble donné
|F| `strerror` | chaîne décrivant un code d'erreur

=== Divers     [diverschaines]

|T| `size_t`    | voyez [stddef.h](#stddef)
|C| `NULL`      | voyez [stddef.h](#stddef)


== Classification des caractères (`<ctype.h>`) [ctype]

|M| `isprint`   | teste si un caractère a un glyphe
|M| `isgraph`   | teste si un caractère a un glyphe, non blanc
|M| `isalnum`   | teste si un caractère est une lettre ou un chiffre
|M| `isalpha`   | teste si un caractère est une lettre
|M| `isupper`   | teste si un caractère est une lettre majuscule
|M| `islower`   | teste si un caractère est une lettre minuscule
|M| `isdigit`   | teste si un caractère est un chiffre
|M| `isxdigit`  | teste si un caractère est un chiffre hexadécimal
|M| `ispunct`   | teste si un caractère est un signe de ponctuation
|M| `isspace`   | teste si un caractère est une sorte d'espace
|M| `iscntrl`   | teste si un caractère est un caractère de contrôle
|M| `tolower`   | convertit un caractère en minuscule
|M| `toupper`   | convertit un caractère en majuscule


== Fonctions mathématiques (`<math.h>`)        [math]

Sous les systèmes de type Unix, il faut lier le programme avec la
bibliothèque `-lm`.

|F| `fabs`      | valeur absolue
|F| `fmod`      | reste
|F| `ceil`      | plafond
|F| `floor`     | plancher
|F| `modf`      | parties entières et fractionnaires
|F| `cos`       | cosinus
|F| `sin`       | sinus
|F| `tan`       | tangente
|F| `acos`      | arc cosinus
|F| `asin`      | arc sinus
|F| `atan`      | arc tangente
|F| `atan2`     | arc tangente de deux variables avec ajustement du cadrant
|F| `exp`       | exponentielle
|F| `cosh`      | cosinus hyperbolique
|F| `sinh`      | sinus hyperbolique
|F| `tanh`      | tangente hyperbolique
|F| `log`       | logarithme népérien
|F| `log10`     | logarithme en base 10
|F| `pow`       | puissance
|F| `sqrt`      | racine carrée
|F| `frexp`     | décomposition en fraction normalisée en base 2
|F| `ldexp`     | produit par une puissance de 2
|C| `HUGE_VAL`  | valeur représentant un dépassement de capacité


== Entrées, sorties et manipulations de fichiers (`<stdio.h>`) [stdio]

=== Opérations sur les fichiers        [opsfichiers]

|C| `FILENAME_MAX` | taille recommandée d'un tableau contenant un nom de fichier
|C| `L_tmpnam`  | taille requise d'un tableau pour un nom de fichier temporaire
|C| `TMP_MAX`   | minimum garanti de noms de fichier temporaires uniques
|F| `remove`    | supprime un fichier
|F| `rename`    | renomme (déplace) un fichier
|F| `tmpnam`    | génère un nom de fichier temporaire

=== Opérations sur les flux    [flux]

|T| `FILE`      | flux d'entrée ou de sortie
|T| `fpos_t`    | position dans un fichier ; pour `fgetpos` et `fsetpos`
|C| `FOPEN_MAX` | minimum garanti de fichiers pouvant être ouverts simultanément
|C| `EOF`       | indicateur de fin d'erreur ou de fin de fichier
|V| `stdin`     | flux entrant standard (/souvent/, la console)
|V| `stdout`    | flux sortant standard (/souvent/, la console)
|V| `stderr`    | flux sortant pour les erreurs (/souvent/, la console)
|F| `tmpfile`   | ouvre un flux temporaire
|F| `fopen`     | ouvre un fichier
|F| `fclose`    | ferme un flux
|F| `freopen`   | rouvre un fichier
|F| `feof`      | différencie une fin de fichier d'une erreur
|F| `ferror`    | différencie une erreur d'une fin de fichier
|F| `clearerr`  | suppression de l'indicateur d'erreur sur un flux
|F| `ftell`     | position actuelle du curseur d'un flux
|F| `fseek`     | déplace le curseur dans un flux
|F| `rewind`    | déplace le curseur d'un flux au début
|C| `SEEK_SET`  | point de référence pour `fseek` : début du flux
|C| `SEEK_CUR`  | point de référence pour `fseek` : position actuelle
|C| `SEEK_END`  | point de référence pour `fseek` : fin du flux
|F| `fgetpos`   | position étendue du curseur (`fpos_t`)
|F| `fsetpos`   | déplace le curseur à une position étendue (`fpos_t`)
|F| `setbuf`    | active l'emploi d'un tampon complet pour un flux
|F| `setvbuf`   | décide de l'emploi d'un tampon pour un flux
|C| `_IOFBF`    | mode pour `setvbuf` : emploi d'un tampon complet
|C| `_IOLBF`    | mode pour `setvbuf` : emploi d'un tampon pour une ligne
|C| `_IONBF`    | mode pour `setvbuf` : emploi d'aucun tampon
|C| `BUFSIZ`    | taille par défaut du tampon
|F| `fflush`    | force la synchronisation d'un flux /sortant/ avec son support

=== Opérations d'entrée et de sortie   [esfichiers]

|F| `fgetc`   | lit un caractère
|M| `getc`    | version /macro/ de `fgetc` ; lit un caractère
|M| `getchar` | lit un caractère sur `stdin`
|F| `fputc`   | écrit un caractère
|M| `putc`    | version /macro/ de `fputc`; écrit un caractère
|M| `putchar` | écrit un caractère sur `stdout`
|F| `ungetc`  | ajoute un caractère à lire au début d'un flux entrant
|F| `fgets`   | lit une ligne
|F| `fputs`   | écrit une chaîne de caractères
|F| `puts`    | écrit une chaîne de caractères et retour à la ligne sur `stdout`
|F| `fread`   | lit par blocs
|F| `fwrite`  | écrit par blocs
|F| `fscanf`  | lit selon un format
|F| `scanf`   | lit selon un format sur `stdin`
|F| `fprintf` | écrit selon un format
|F| `printf`  | écrit selon un format sur `stdout`
|F| `vfprintf`| écrit selon un format avec une `va_list`
|F| `vprintf` | écrit selon un format avec une `va_list` sur `stdin`
|F| `sscanf`  | lit selon un format depuis une chaîne
|F| `sprintf` | écrit selon un format, dans une chaîne
|F| `vsprintf`| écrit selon un format, dans une chaîne, avec une `va_list`
|F| `perror`  | écrit un message d'erreur associé à la valeur d'`errno`

=== Divers     [diversfichiers]

|T| `size_t`    | voyez [stddef.h](#stddef)
|C| `NULL`      | voyez [stddef.h](#stddef)
|F| `gets`      | /dangereuse/

`gets` n'aura pas plus de description. Si vous aviez une vraie raison
vous poussant à l'utiliser (et je n'en vois aucune), vous n'auriez pas
besoin de moi pour vous la rappeler.


== Utilitaires généraux (`<stdlib.h>`) [stdlib]

=== Interaction avec l'environnement   [env]

|F| `abort`             | abandonne (termine brutalement) le programme
|F| `atexit`            | enregistre une fonction à exécuter en fin de programme
|F| `exit`              | termine l'exécution du programme
|C| `EXIT_FAILURE`      | code pour `exit` : échec
|C| `EXIT_SUCCESS`      | code pour `exit` : réussite
|F| `getenv`            | récupère une variable d'environnement par son nom
|F| `system`            | exécute une commande au +shell+(en)

=== Gestion de la mémoire      [mem]

|F| `malloc`            | alloue un bloc de mémoire
|F| `calloc`            | alloue un tableau dont les bits sont initialisés à 0
|F| `free`              | libère de la mémoire précédemment allouée
|F| `realloc`           | change la taille d'un bloc de mémoire

=== Utilitaires        [utils]

|T| `div_t`     | type de retour de `div`
|T| `ldiv_t`    | type de retour de `ldiv`
|F| `abs`       | valeur absolue d'un `int`
|F| `labs`      | valeur absolue d'un `long`
|F| `div`       | division euclidienne d'`int`
|F| `ldiv`      | division euclidienne de `long`
|F| `strtol`    | convertit un nombre sous forme textuelle en `long`
|F| `strtoul`   | convertit un nombre sous forme textuelle en `unsigned long`
|F| `strtod`    | convertit un nombre sous forme textuelle en `double`
|F| `atoi`      | convertit un nombre sous forme textuelle en `int`
|F| `atol`      | convertit un nombre sous forme textuelle en `long`
|F| `atof`      | convertit un nombre sous forme textuelle en `float`
|F| `qsort`     | trie un tableau
|F| `bsearch`   | recherche dans un tableau trié

=== Chaînes de caractères polyoctets   [mb]

|V| `MB_CUR_MAX`        | nombre maximal d'octets par caractère polyoctet
  avec les paramètres régionaux en vigueur
|F| `mblen`             | longueur d'un caractère polyoctet
|F| `mbtowc`            | convertit un caractère polyoctet en caractère étendu
|F| `wctomb`            | convertit un caractère étendu en caractère polyoctet
|F| `mbstowcs`          | convertit une chaîne de caractères polyoctets
  en chaîne de caractères étendus
|F| `wcstombs`          | convertit une chaîne de caractères étendus
  en chaîne de caractères polyoctets

=== Nombres aléatoires [alea]

|C| `RAND_MAX`          | nombre maximal pouvant être généré par `rand`
|F| `srand`             | initialise le générateur aléatoire
|F| `rand`              | génère un entier aléatoire

=== Divers     [diversutils]

|T| `size_t`    | voyez [stddef.h](#stddef)
|T| `wchar_t`   | voyez [stddef.h](#stddef)
|C| `NULL`      | voyez [stddef.h](#stddef)


== Dates et heures (`<time.h>`)        [time]

|T| `time_t`    | type arithmétique représentant le temps écoulé depuis l'Époque
|T| `struct tm` | date et heure sous forme décomposée
|T| `clock_t`   | nombre de battements renvoyés par `clock`
|C| `CLOCKS_PER_SEC` | nombre de battements renvoyés par `clock` par seconde
|F| `time`      | instant présent
|F| `difftime`  | nombre de secondes entre deux `time_t`
|F| `mktime`    | crée un `time_t` à partir d'un `struct tm`
|F| `gmtime`    | décompose un `time_t` en un `struct tm` selon l'heure .GMT.
|F| `localtime` | décompose un `time_t` en un `struct tm` selon l'heure locale
|F| `strftime`  | écrit un `struct tm` selon un format, dans une chaîne
|F| `ctime`     | convertit un `time_t` en représentation textuelle
|F| `asctime`   | convertit un `struct tm` en représentation textuelle
|F| `clock`     | compteur temporel usant d'une unité arbitraire
|T| `size_t`    | voyez [stddef.h](#stddef)
|C| `NULL`      | voyez [stddef.h](#stddef)


== Diagnostic (`<assert.h>`)   [assert]

|M| `NDEBUG`    | supprime les appels à `assert` /si défini/
|M| `assert`    | abandon conditionnel du programme avec message d'erreur


== Gestion des erreurs du système (`<errno.h>`)        [errno]

|V| `errno`     | en cas d'erreur, expression la décrivant
|C| `EDOM`      | valeur possible d'`errno` : erreur mathématique de domaine
|C| `ERANGE`    | valeur possible d'`errno` : erreur mathématique d'intervalle


== Gestion des signaux (`<signal.h>`)  [signal]

|T| `sig_atomic_t`      | type entier muni d'opérations atomiques
|F| `raise`             | émet un signal
|F| `signal`            | enregistre une action à effectuer à la réception
  d'un signal
|C| `SIGABRT`           | signal d'abandon du programme
|C| `SIGFPE`            | signal d'erreur de calcul flottant
|C| `SIGILL`            | signal d'instruction illégale
|C| `SIGINT`            | signal interactif
|C| `SIGSEGV`           | signal d'erreur d'accès à la mémoire
|C| `SIGTERM`           | signal de terminaison extérieure du programme
|C| `SIG_DFL`           | action pour `signal` : action par défaut
|C| `SIG_IGN`           | action pour `signal` : ignore un signal reçu
|C| `SIG_ERR`           | valeur indicant une erreur


== Considérations régionales (`<locale.h>`)    [locale]

|T| `struct lconv` | paramètres régionaux
|C| `LC_ALL`       | catégorie pour `setlocale` : toute catégorie
|C| `LC_COLLATE`   | catégorie pour `setlocale` : ordre des caractères
|C| `LC_CTYPE`     | catégorie pour `setlocale` : classification des caractères
|C| `LC_MONETARY`  | catégorie pour `setlocale` : système monétaire
|C| `LC_NUMERIC`   | catégorie pour `setlocale` : nombres
|C| `LC_TIME`      | catégorie pour `setlocale` : dates et heures
|F| `setlocale`    | change ou examine la +locale+(en) en vigueur
|F| `localeconv`   | informations sur l'écriture des nombres
|C| `NULL`         | voyez [stddef.h](#stddef)


== Gestion des listes d'arguments variables (`<stdarg.h>`)     [stdarg]

|T| `va_list`   | liste d'arguments variable
|M| `va_start`  | début d'itération sur une liste d'arguments variable
|M| `va_arg`    | prochain argument dans une liste d'arguments variable
|M| `va_end`    | fin d'itération sur une liste d'arguments variable


== Sauts inter-procéduraux (`<setjmp.h>`)      [setjmp]

|T| `jmp_buf`   | informations contextuelles pour les sauts
|F| `setjmp`    | /sous certaines réserves/, sauvegarde le contexte actuel
|F| `longjmp`   | téléporte vers un contexte sauvegardé


= Remarques     [remq]

On semble en douter ; je vais donc clarifier les choses. /Toutes/ les
descriptions ici présentes sont de moi ; je ne les ai /pas/ recopiées
d'une autre source ; je n'en ai pas le droit, pas plus qu'un autre
a le droit de reprendre mon travail à son compte.

Je sais que certains grands sites dont je tairai le nom n'hésitent pas
à reproduire des paragraphes entiers d'autres documentations en
apposant leurs noms d'auteur dessus. Mon site est certes modeste, mais
le contenu est de ma main.

%-