C`atomic_fetch_and(object, operand)` de `<stdatomic.h>` effectue atomiquement `*object &= operand` sur un type entier atomique et renvoie la valeur antérieure. C’est une seule opération read-modify-write.
Avancé · C23C`atomic_fetch_or(object, operand)` de `<stdatomic.h>` effectue atomiquement `*object |= operand` sur un type entier atomique et renvoie la valeur antérieure à la pose des bits. C’est une seule opération read-modify-write.
Avancé · C23C`atomic_fetch_sub(object, operand)` de `<stdatomic.h>` soustrait atomiquement `operand` d’un objet entier ou pointeur atomique et renvoie la valeur antérieure. C’est une seule opération read-modify-write.
Avancé · C23C`atomic_fetch_xor(object, operand)` de `<stdatomic.h>` effectue atomiquement `*object ^= operand` sur un type entier atomique et renvoie la valeur antérieure au basculement des bits. C’est une seule opération read-modify-write.
Avancé · C23C`atomic_flag_clear(object)` de `<stdatomic.h>` place atomiquement l’`atomic_flag` pointé dans l’état effacé et ne renvoie aucune valeur. La forme de base utilise `memory_order_seq_cst`.
Avancé · C23C`atomic_flag_test_and_set(object)` de `<stdatomic.h>` pose atomiquement un `atomic_flag` et renvoie son état précédent : `false` signifie acquisition d’un drapeau auparavant effacé, `true` qu’il était déjà posé.
Avancé · C23C`atomic_init(obj, value)` de `<stdatomic.h>` initialise l’objet atomique pointé avec `value`, y compris tout état supplémentaire requis par l’implémentation, et ne renvoie rien. Si le stockage n’a pas de type déclaré, l’appel lui donne le type effectif atomique `A`.
Avancé · C23C`atomic_load(object)` renvoie atomiquement la valeur de l’objet atomique pointé. La forme sans `_explicit` équivaut à `atomic_load_explicit(..., memory_order_seq_cst)` ; la qualification `volatile` du pointeur préserve la sémantique des registres matériels.
Avancé · C23C`atomic_signal_fence(order)` n’établit des contraintes d’ordre qu’entre le code du thread et un gestionnaire de signal exécuté dans ce même thread. Elle partage les classes d’ordre de `atomic_thread_fence`, ne renvoie rien et n’est pas générique.
Avancé · C23C`atomic_store(object, desired)` remplace atomiquement la valeur de l’objet pointé par `desired` et ne renvoie rien. La forme sans `_explicit` utilise `memory_order_seq_cst` ; c’est une écriture, pas une opération read-modify-write.
Avancé · C23C`atomic_thread_fence(order)` établit une barrière mémoire sans lire ni écrire un objet atomique précis. Relaxed est sans effet ; consume/acquire donne une barrière acquire, release une release, acq_rel les deux, et seq_cst participe en plus à l’ordre séquentiellement cohérent. Elle ne renvoie rien.
Avancé · C23Cat_quick_exit, défini dans <stdlib.h>, enregistre une fonction appelée par quick_exit. Il renvoie 0 en cas de succès et une valeur non nulle en cas d’échec.
Intermédiaire · C23; repository compiler flag, production runtime not attestedC`bsearch(key, base, nmemb, size, compar)` cherche parmi `nmemb` objets de `size` octets et renvoie un pointeur vers un élément égal à `key`, ou null. Le comparateur reçoit d’abord la clé puis l’élément et renvoie une valeur négative, nulle ou positive.
Intermédiaire · C23C`c16rtomb(s, c16, ps)` convertit une unité `char16_t` codée en UTF-16 vers la représentation multioctet du `LC_CTYPE` courant, stocke au plus `MB_CUR_MAX` octets et renvoie leur nombre, séquences de décalage comprises.
Avancé · C23C`c32rtomb(s, c32, ps)` convertit une unité `char32_t` codée en UTF-32 vers la représentation multioctet du `LC_CTYPE` courant, stocke au plus `MB_CUR_MAX` octets et renvoie leur nombre, séquences de décalage comprises.
Avancé · C23C`c8rtomb(s, c8, ps)` convertit une unité `char8_t` codée en UTF-8 vers la représentation multioctet du `LC_CTYPE` courant, stocke au plus `MB_CUR_MAX` octets et renvoie leur nombre, séquences de décalage comprises.
Avancé · C23C`calloc(nmemb, size)` de `<stdlib.h>` alloue un tableau de `nmemb` objets de `size` octets, met à zéro tous les bits de la zone et renvoie son pointeur ou null. C23 exige aussi null si le produit `nmemb * size` déborderait `size_t`.
Intermédiaire · C23C`call_once(flag, func)` utilise un `once_flag` pour appeler `func` exactement une fois, lors du premier appel effectif avec cet objet, et ne renvoie rien. La fin de cet appel se synchronise avec tout autre appel du même drapeau : ceux déjà en cours et attendant `func`, ainsi que les appels ultérieurs.
Avancé · C23C`cbrt(x)` de `<math.h>` prend un `double` et renvoie sa racine cubique réelle ; `cbrtf` et `cbrtl` fournissent les formes `float` et `long double`. Un argument négatif donne un résultat réel négatif.
Débutant · C23C`ceil(x)` de `<math.h>` renvoie le plus petit entier non inférieur à `double x`, toujours représenté comme `double` ; `ceilf` et `ceill` conservent `float` et `long double`. C’est un arrondi vers l’infini positif.
Débutant · C23C`clearerr(stream)` de `<stdio.h>` efface à la fois l’indicateur de fin de fichier et l’indicateur d’erreur du flux `FILE` indiqué ; elle ne renvoie rien. Elle n’effectue aucune entrée-sortie.
Intermédiaire · C23C`clock()` de `<time.h>` renvoie la meilleure approximation disponible du temps processeur activement consommé par le programme depuis une origine liée à son lancement mais définie par l’implémentation. Le résultat est un `clock_t` ; divisez par `CLOCKS_PER_SEC` pour obtenir des secondes.
Intermédiaire · C23C`cnd_broadcast(cond)` de `<threads.h>` débloque tous les threads bloqués sur cette variable de condition au moment de l’appel. Sans attente, elle ne fait rien ; elle renvoie `thrd_success` ou `thrd_error` si la requête ne peut être satisfaite.
Avancé · C23C`cnd_destroy(cond)` libère toutes les ressources d’une variable de condition précédemment initialisée et ne renvoie rien. C23 exige qu’aucun thread ne soit bloqué dessus au moment de l’appel.
Intermédiaire · C23