atomic_fetch_and — funzione generica atomica C23
`atomic_fetch_and(object, operand)` di `<stdatomic.h>` esegue atomicamente `*object &= operand` su un tipo intero atomico e restituisce il valore precedente. È un’unica operazione read-modify-write.
CKTIS / C
Sintassi, operatori e concetti di programmazione. Trova una spiegazione, consulta un esempio e torna a imparare.
`atomic_fetch_and(object, operand)` di `<stdatomic.h>` esegue atomicamente `*object &= operand` su un tipo intero atomico e restituisce il valore precedente. È un’unica operazione read-modify-write.
`atomic_fetch_or(object, operand)` di `<stdatomic.h>` esegue atomicamente `*object |= operand` su un tipo intero atomico e restituisce il valore precedente all’impostazione dei bit. È un’unica operazione read-modify-write.
`atomic_fetch_sub(object, operand)` di `<stdatomic.h>` sottrae atomicamente `operand` da un oggetto intero o puntatore atomico e restituisce il valore precedente. È un’unica operazione read-modify-write.
`atomic_fetch_xor(object, operand)` di `<stdatomic.h>` esegue atomicamente `*object ^= operand` su un tipo intero atomico e restituisce il valore precedente al toggle dei bit. È un’unica operazione read-modify-write.
`atomic_flag_clear(object)` di `<stdatomic.h>` pone atomicamente l’`atomic_flag` puntato nello stato libero e non restituisce un valore. La forma base usa `memory_order_seq_cst`.
`atomic_flag_test_and_set(object)` di `<stdatomic.h>` imposta atomicamente un `atomic_flag` e restituisce lo stato precedente: `false` indica l’acquisizione di un flag prima libero, `true` che era già impostato.
`atomic_init(obj, value)` di `<stdatomic.h>` inizializza l’oggetto atomico puntato con `value`, compreso lo stato aggiuntivo richiesto dall’implementazione, e non restituisce valori. Se la memoria non ha un tipo dichiarato, la chiamata le assegna il tipo effettivo atomico `A`.
`atomic_load(object)` restituisce atomicamente il valore dell’oggetto atomico puntato. La forma senza `_explicit` equivale a `atomic_load_explicit(..., memory_order_seq_cst)`; il `volatile` del puntatore preserva la semantica dei registri hardware.
`atomic_signal_fence(order)` stabilisce vincoli d’ordine solo tra il codice del thread e un gestore di segnali eseguito nello stesso thread. Ha le classi d’ordine di `atomic_thread_fence`, non restituisce valori e non è generica.
`atomic_store(object, desired)` sostituisce atomicamente il valore dell’oggetto puntato con `desired` e non restituisce valori. La forma senza `_explicit` usa `memory_order_seq_cst`; è una scrittura, non una read-modify-write.
`atomic_thread_fence(order)` stabilisce una barriera di memoria senza leggere o scrivere uno specifico oggetto atomico. Relaxed non ha effetto; consume/acquire crea una fence acquire, release una release, acq_rel entrambe e seq_cst partecipa anche all’ordine sequenzialmente consistente. Non restituisce valori.
at_quick_exit, da <stdlib.h>, registra una funzione chiamata da quick_exit. Restituisce 0 in caso di successo e un valore diverso da zero in caso di errore.
`bsearch(key, base, nmemb, size, compar)` cerca tra `nmemb` oggetti di `size` byte e restituisce un puntatore a un elemento uguale a `key`, oppure null. Il comparatore riceve prima la chiave e poi l’elemento, restituendo negativo, zero o positivo.
`c16rtomb(s, c16, ps)` converte un’unità `char16_t` codificata come UTF-16 nella rappresentazione multibyte del `LC_CTYPE` corrente, memorizza al massimo `MB_CUR_MAX` byte e restituisce il numero, incluse le sequenze di shift.
`c32rtomb(s, c32, ps)` converte un’unità `char32_t` codificata come UTF-32 nella rappresentazione multibyte del `LC_CTYPE` corrente, memorizza al massimo `MB_CUR_MAX` byte e restituisce il numero, incluse le sequenze di shift.
`c8rtomb(s, c8, ps)` converte un’unità `char8_t` codificata come UTF-8 nella rappresentazione multibyte del `LC_CTYPE` corrente, memorizza al massimo `MB_CUR_MAX` byte e restituisce il numero, incluse le sequenze di shift.
`calloc(nmemb, size)` di `<stdlib.h>` alloca un array di `nmemb` oggetti da `size` byte, azzera ogni bit della regione e restituisce il puntatore oppure null. C23 richiede null anche se il prodotto `nmemb * size` causerebbe wrap di `size_t`.
`call_once(flag, func)` usa un `once_flag` per chiamare `func` esattamente una volta, alla prima chiamata effettiva con quell’oggetto, e non restituisce valori. Il completamento sincronizza con ogni altra chiamata sulla stessa flag: quelle già in corso e in attesa di `func`, oltre alle successive.
`cbrt(x)` di `<math.h>` accetta un `double` e restituisce la radice cubica reale; `cbrtf` e `cbrtl` sono le forme `float` e `long double`. Un argomento negativo produce un risultato reale negativo.
`ceil(x)` di `<math.h>` restituisce il minimo valore intero non minore di `double x`, ancora rappresentato come `double`; `ceilf` e `ceill` conservano `float` e `long double`. È arrotondamento verso infinito positivo.
`clearerr(stream)` di `<stdio.h>` cancella sia l’indicatore di fine file sia quello di errore dello stream `FILE` indicato; non restituisce valori. Non esegue operazioni di input o output.
`clock()` di `<time.h>` restituisce la migliore approssimazione disponibile del tempo di processore consumato attivamente dal programma da un’epoca legata all’avvio ma definita dall’implementazione. Il risultato è `clock_t`; dividilo per `CLOCKS_PER_SEC` per ottenere secondi.
`cnd_broadcast(cond)` di `<threads.h>` sblocca tutti i thread bloccati su quella condition variable al momento della chiamata. Se non ci sono attese non fa nulla; restituisce `thrd_success` o `thrd_error` se la richiesta non può essere soddisfatta.
`cnd_destroy(cond)` rilascia tutte le risorse di una condition variable inizializzata in precedenza e non restituisce valori. C23 richiede che nessun thread sia bloccato in attesa al momento della chiamata.