C`cnd_init(cond)` crée une nouvelle variable de condition et, en cas de succès, place dans `*cond` une valeur qui l’identifie de manière unique. Elle renvoie `thrd_success`, `thrd_nomem` si la mémoire manque, ou `thrd_error` si la requête ne peut être satisfaite.
Intermédiaire · C23C`cnd_signal(cond)` débloque un thread bloqué sur `cond` au moment de l’appel. Sans attente, elle ne fait rien et renvoie quand même `thrd_success` ; sinon le résultat est `thrd_success` ou `thrd_error`.
Avancé · C23C`cnd_timedwait(cond, mtx, ts)` déverrouille atomiquement le `mtx` détenu et attend un signal/broadcast, l’heure civile absolue `TIME_UTC` de `*ts` ou un déblocage non spécifié. Avant un retour normal, elle verrouille de nouveau ce mutex.
Avancé · C23C`cnd_wait(cond, mtx)` de `<threads.h>` déverrouille atomiquement le `mtx` détenu et bloque jusqu’à un signal, un broadcast ou un déblocage non spécifié. Avant de revenir, elle verrouille de nouveau `mtx` ; résultat : `thrd_success` ou `thrd_error`.
Avancé · C23C`copysign(x, y)` de `<math.h>` renvoie la magnitude de `x` avec le signe de `y` ; si `x` est NaN, le résultat est un NaN portant le signe de `y`. Si une valeur est non signée, C23 rend le signe éventuel du résultat dépendant de l’implémentation.
Intermédiaire · C23C`cos(x)` de `<math.h>` calcule le cosinus de `x` exprimé en radians et renvoie `double` ; `cosf` et `cosl` couvrent `float` et `long double`. Pour un argument fini, le C23 de base ne spécifie pas d’erreur de domaine.
Débutant · C23C`cosh(x)` de `<math.h>` renvoie le cosinus hyperbolique de `x`, mathématiquement `(e^x + e^-x) / 2`. La fonction est paire ; C23 impose une erreur de plage si la magnitude du `x` fini est trop grande.
Intermédiaire · C23C`ctime(timer)` de `<time.h>` convertit le temps civil `time_t` pointé en chaîne d’heure locale et renvoie le pointeur de l’équivalent `asctime(localtime(timer))`. En C23, la déclaration est `[[deprecated]]` ; cette fonction obsolescente est à éviter dans le nouveau code.
Intermédiaire · C23C`difftime(time1, time0)` de `<time.h>` calcule `time1 - time0` pour deux temps civils `time_t` et renvoie la différence en secondes comme `double`. C’est l’interface portable, car l’encodage de `time_t` n’est pas spécifié.
Intermédiaire · C23C`div(numer, denom)` de `<stdlib.h>` calcule ensemble quotient entier et reste, et renvoie un `div_t` contenant `quot` et `rem`. La division entière tronque vers zéro et `numer == quot * denom + rem`.
Débutant · C23C`errno` de `<errno.h>` est une macro qui se développe en lvalue modifiable de type `int` à durée de stockage de thread. Ce n’est ni une fonction ni une constante : utilisez `errno`, jamais `errno()`, et chaque thread possède son objet.
Intermédiaire · C23C`exit(status)` de `<stdlib.h>` provoque la terminaison normale et ne revient pas. Elle appelle d’abord les fonctions `atexit` dans l’ordre inverse d’enregistrement, puis vide et ferme les flux, supprime les fichiers `tmpfile` et rend enfin le statut à l’environnement hôte.
Avancé · C23C`exp(x)` de `<math.h>` calcule l’exponentielle de base e et renvoie `e^x` comme `double` ; `expf` et `expl` couvrent `float` et `long double`. C23 impose une erreur de plage si la magnitude du `x` fini est trop grande.
Intermédiaire · C23C`exp2(x)` de `<math.h>` calcule `2^x` et renvoie un `double` ; `exp2f` et `exp2l` acceptent respectivement `float` et `long double`. C23 signale une erreur de plage si la magnitude du `x` fini est trop grande.
Intermédiaire · C23C`expm1(x)` de `<math.h>` calcule `e^x - 1` comme `double` ; `expm1f` et `expm1l` couvrent `float` et `long double`. Elle conserve la précision pour un `x` minuscule, alors que calculer séparément `exp(x) - 1` perd des chiffres en soustrayant des valeurs proches.
Intermédiaire · C23C`fabs(x)` de `<math.h>` renvoie la valeur absolue d’un `double` ; `fabsf` et `fabsl` couvrent `float` et `long double`. Contrairement à l’entier `abs`, elle n’a pas le problème du correspondant positif non représentable du plus petit entier.
Débutant · C23C`fclose(stream)` de `<stdio.h>` vide le flux indiqué, remet les données non écrites à l’environnement hôte, abandonne l’entrée non lue, ferme le fichier associé et dissocie l’objet `FILE`. Elle renvoie zéro en cas de succès ou `EOF` en cas d’échec.
Intermédiaire · C23C`feof(stream)` de `<stdio.h>` teste l’indicateur de fin de fichier d’un flux `FILE` ouvert. Elle renvoie une valeur non nulle si et seulement si cet indicateur est posé ; elle ne lit rien et ne renvoie pas elle-même la constante `EOF`.
Débutant · C23C`ferror(stream)` de `<stdio.h>` teste l’indicateur d’erreur d’un flux `FILE` ouvert. Elle renvoie une valeur non nulle si et seulement si l’indicateur est posé ; elle n’effectue aucune E/S, ne fournit pas un code d’erreur précis et ne modifie pas l’état du flux.
Débutant · C23C`fflush(stream)` de `<stdio.h>` remet à l’environnement hôte les données de sortie tamponnées non écrites d’un flux de sortie ou de mise à jour admissible. `fflush(NULL)` tente l’opération pour tous ces flux ouverts ; elle renvoie zéro en cas de succès ou `EOF` avec indicateur d’erreur en cas d’échec.
Intermédiaire · C23C`fgetc(stream)` de `<stdio.h>` lit le caractère suivant d’un flux d’entrée, avance sa position et renvoie l’octet interprété comme `unsigned char`, puis converti en `int`. À la fin ou en cas d’erreur, elle renvoie `EOF` et pose l’indicateur correspondant.
Débutant · C23C`fgetpos(stream, pos)` de `<stdio.h>` stocke l’état de position courant d’un flux ouvert dans l’objet `fpos_t` désigné par `pos`. Elle renvoie zéro en cas de succès et une valeur non nulle en cas d’échec ; l’état sert à un futur `fsetpos`.
Intermédiaire · C23C`fgets(s, n, stream)` de `<stdio.h>` lit au plus `n - 1` caractères dans le tableau `s`, en s’arrêtant après un saut de ligne lu ou à la fin. Le saut de ligne reste dans le tableau et la fonction ajoute ensuite `\0`.
Débutant · C23C`floor(x)` de `<math.h>` renvoie la plus grande valeur flottante entière qui n’est pas supérieure à `x` ; le résultat reste un `double`. `floorf` et `floorl` couvrent `float` et `long double`, sans dépendre du mode d’arrondi courant.
Débutant · C23