C`fma(x, y, z)` de `<math.h>` calcule `x*y + z` comme si produit et somme avaient une précision illimitée, puis n’arrondit qu’une fois vers `double`. `fmaf` et `fmal` fournissent l’opération pour les autres types flottants.
Avancé · C23C`fmax(x, y)` de `<math.h>` renvoie la plus grande valeur numérique de deux `double` ; `fmaxf` et `fmaxl` couvrent les autres types. Si un seul argument est NaN, la valeur numérique de l’autre est renvoyée.
Intermédiaire · C23C`fmin(x, y)` de `<math.h>` renvoie la plus petite valeur numérique de deux `double` ; `fminf` et `fminl` couvrent les autres types. Si un seul argument est NaN, l’autre valeur numérique est renvoyée.
Intermédiaire · C23C`fmod(x, y)` de `<math.h>` renvoie `x - n*y`, où `n` est `x/y` tronqué vers zéro ; la magnitude est inférieure à `|y|` et le signe suit `x`.
Intermédiaire · C23C`fopen(filename, mode)` de `<stdio.h>` ouvre le fichier nommé, l’associe à un nouveau flux `FILE` et renvoie son pointeur ou null en cas d’échec. `r`, `w`, `a`, les options `+` et `b`, et `x` seulement dans les modes énumérés fondés sur `w` choisissent accès, création, troncature, ajout et exclusivité.
Intermédiaire · C23C`fprintf(stream, format, ...)` écrit des données formatées dans le flux et renvoie le nombre de caractères, ou une valeur négative en cas d’erreur de codage/sortie. Chaque conversion de `format` doit correspondre au type réel.
Intermédiaire · C23C`fputc(c, stream)` de `<stdio.h>` écrit le caractère obtenu en convertissant `c` en `unsigned char`. En cas de succès elle renvoie cette valeur convertie en `int` ; en cas d’échec elle renvoie `EOF` et pose l’indicateur d’erreur.
Débutant · C23C`fputs(s, stream)` de `<stdio.h>` écrit tous les caractères de `s` avant l’octet nul final ; elle n’écrit ni le terminateur ni un saut de ligne automatique. Retour non négatif en cas de succès ou `EOF` en cas d’échec.
Débutant · C23C`fread(ptr, size, nmemb, stream)` de `<stdio.h>` tente de lire `nmemb` éléments de `size` octets dans `ptr` et renvoie le nombre d’éléments complets. Les données sont une suite d’`unsigned char` ; un compte court signifie fin ou erreur.
Intermédiaire · C23C`free(ptr)` de `<stdlib.h>` libère le stockage désigné par `ptr` pour de futures allocations ; un pointeur null ne provoque aucune action et la fonction ne renvoie rien. Un pointeur non nul doit provenir d’une fonction mémoire compatible et désigner encore une allocation vivante.
Débutant · C23C`freopen(filename, mode, stream)` de `<stdio.h>` ferme le fichier associé puis réassocie le même objet `FILE` au fichier et au mode indiqués. Elle renvoie `stream` en cas de succès ou null en cas d’échec.
Intermédiaire · C23C`frexp(value, exp)` de `<math.h>` décompose une valeur finie avec `value == fraction * 2^*exp` ; hors zéro, la magnitude de la fraction est dans `[0.5, 1)`. Elle renvoie la fraction et stocke l’exposant via un pointeur valide.
Intermédiaire · C23C`fscanf(stream, format, ...)` de `<stdio.h>` lit les caractères d’un flux selon les directives de format et stocke les conversions via les arguments pointeurs successifs. Elle renvoie le nombre d’affectations réalisées, ou `EOF` si une défaillance d’entrée précède la première conversion.
Intermédiaire · C23C`fseek(stream, offset, whence)` de `<stdio.h>` fixe la position du fichier par rapport à `SEEK_SET`, `SEEK_CUR` ou `SEEK_END`. Elle renvoie `0` au succès et une valeur non nulle à l’échec ; le succès efface l’indicateur de fin et annule les effets de `ungetc`.
Intermédiaire · C23C`fsetpos(stream, pos)` de `<stdio.h>` restaure l’indicateur de position et, s’il existe, l’objet `mbstate_t` depuis une valeur enregistrée par un `fgetpos` réussi sur un flux associé au même fichier. Elle renvoie `0` au succès et une valeur non nulle à l’échec.
Intermédiaire · C23C`ftell(stream)` de `<stdio.h>` obtient l’indicateur courant de position. Pour un flux binaire, le résultat compte les caractères depuis le début ; pour un flux texte, c’est une information opaque à fournir à `fseek` avec `SEEK_SET` afin de retrouver la même position.
Intermédiaire · C23C`fwrite(ptr, size, nmemb, stream)` de `<stdio.h>` écrit dans un flux jusqu’à `nmemb` objets de `size` octets depuis le tableau désigné par `ptr`. Chaque objet est traité comme des appels successifs à `fputc` sur sa représentation `unsigned char` ; le retour compte les objets entièrement écrits.
Intermédiaire · C23C`getchar()` de `<stdio.h>` obtient le caractère suivant de l’entrée standard et équivaut à `getc(stdin)`. Elle renvoie le caractère lu comme `unsigned char` converti en `int`, ou la valeur de macro `EOF` à la fin des données ou en cas d’erreur de lecture.
Débutant · C23C`getenv(name)` de `<stdlib.h>` cherche dans la liste d’environnement de l’hôte une entrée correspondant à la chaîne terminée par null `name`. Elle renvoie un pointeur vers la chaîne de valeur si l’entrée existe, sinon un pointeur null.
Intermédiaire · C23C`gmtime(timer)` de `<time.h>` convertit la valeur de temps calendaire `time_t` désignée en UTC décomposée dans un objet `struct tm`. Elle renvoie un pointeur vers le résultat, ou null si UTC est indisponible ou la valeur irreprésentable.
Intermédiaire · C23C`hypot(x, y)` de `<math.h>` renvoie le `sqrt(x*x + y*y)` non négatif, mais le calcule sans débordement ou sous-débordement intermédiaire indu. `hypotf` et `hypotl` servent respectivement `float` et `long double`.
Intermédiaire · C23C`isalnum(c)` de `<ctype.h>` renvoie une valeur non nulle si `c` est une lettre ou un chiffre décimal dans la locale courante, comme si `isalpha(c) || isdigit(c)` était vrai. Sinon elle renvoie zéro ; la valeur vraie n’est pas forcément 1.
Débutant · C23C`isalpha(c)` de `<ctype.h>` renvoie une valeur non nulle pour un caractère alphabétique dans la locale courante. Dans la locale `C`, il s’agit des caractères reconnus par `isupper` ou `islower` ; une autre locale peut ajouter des lettres qui ne sont ni contrôle, chiffre, ponctuation ou espace.
Débutant · C23C`isblank(c)` de `<ctype.h>` renvoie une valeur non nulle pour un espacement horizontal standard ou un caractère blank supplémentaire défini par la locale courante. Dans la locale `C`, espace et tabulation horizontale sont vrais ; le saut de ligne est un espace blanc, mais pas blank.
Débutant · C23