atomic_fetch_and — função genérica atómica C23
`atomic_fetch_and(object, operand)` de `<stdatomic.h>` executa atomicamente `*object &= operand` num tipo inteiro atómico e devolve o valor anterior. É uma única operação read-modify-write.
CKTIS / Base de conhecimento
Sintaxe, operadores e conceitos de programação. Encontra uma explicação, consulta um exemplo e continua a aprender.
`atomic_fetch_and(object, operand)` de `<stdatomic.h>` executa atomicamente `*object &= operand` num tipo inteiro atómico e devolve o valor anterior. É uma única operação read-modify-write.
`atomic_fetch_or(object, operand)` de `<stdatomic.h>` executa atomicamente `*object |= operand` num tipo inteiro atómico e devolve o valor anterior à definição dos bits. É uma única operação read-modify-write.
`atomic_fetch_sub(object, operand)` de `<stdatomic.h>` subtrai atomicamente `operand` de um objeto inteiro ou ponteiro atómico e devolve o valor anterior. É uma única operação read-modify-write.
`atomic_fetch_xor(object, operand)` de `<stdatomic.h>` executa atomicamente `*object ^= operand` num tipo inteiro atómico e devolve o valor anterior à alternância dos bits. É uma única operação read-modify-write.
`atomic_flag_clear(object)` de `<stdatomic.h>` coloca atomicamente o `atomic_flag` apontado no estado limpo e não devolve valor. A forma básica usa `memory_order_seq_cst`.
`atomic_flag_test_and_set(object)` de `<stdatomic.h>` define atomicamente um `atomic_flag` e devolve o estado anterior: `false` significa aquisição de uma flag antes limpa e `true` que já estava definida.
`atomic_init(obj, value)` de `<stdatomic.h>` inicializa o objeto atómico apontado com `value`, incluindo estado adicional exigido pela implementação, e não devolve valor. Se o armazenamento não tiver tipo declarado, a chamada atribui-lhe o tipo efetivo atómico `A`.
`atomic_load(object)` devolve atomicamente o valor do objeto atómico apontado. A forma sem `_explicit` equivale a `atomic_load_explicit(..., memory_order_seq_cst)`; o `volatile` do ponteiro preserva a semântica de registos de dispositivo.
`atomic_signal_fence(order)` estabelece restrições de ordem apenas entre código da thread e um tratador de sinal executado nessa mesma thread. Tem as classes de ordem de `atomic_thread_fence`, não devolve valor e não é genérica.
`atomic_store(object, desired)` substitui atomicamente o valor do objeto apontado por `desired` e não devolve valor. A forma sem `_explicit` usa `memory_order_seq_cst`; é uma escrita, não uma read-modify-write.
`atomic_thread_fence(order)` estabelece uma barreira de memória sem ler ou escrever um átomo específico. Relaxed não tem efeito; consume/acquire cria barreira acquire, release uma release, acq_rel ambas e seq_cst participa ainda na ordem sequencialmente consistente. Não devolve valor.
at_quick_exit, de <stdlib.h>, regista uma função chamada por quick_exit. Devolve 0 em caso de sucesso e um valor diferente de zero em caso de falha.
`bsearch(key, base, nmemb, size, compar)` procura entre `nmemb` objetos de `size` bytes e devolve ponteiro para elemento igual a `key`, ou null. O comparador recebe primeiro a chave e depois o elemento, devolvendo valor negativo, zero ou positivo.
`c16rtomb(s, c16, ps)` converte uma unidade `char16_t` codificada como UTF-16 na representação multibyte do `LC_CTYPE` atual, guarda no máximo `MB_CUR_MAX` bytes e devolve o número, incluindo sequências de deslocamento.
`c32rtomb(s, c32, ps)` converte uma unidade `char32_t` codificada como UTF-32 na representação multibyte do `LC_CTYPE` atual, guarda no máximo `MB_CUR_MAX` bytes e devolve o número, incluindo sequências de deslocamento.
`c8rtomb(s, c8, ps)` converte uma unidade `char8_t` codificada como UTF-8 na representação multibyte do `LC_CTYPE` atual, guarda no máximo `MB_CUR_MAX` bytes e devolve o número, incluindo sequências de deslocamento.
`calloc(nmemb, size)` de `<stdlib.h>` aloca um array de `nmemb` objetos com `size` bytes, põe a zero todos os bits da região e devolve o ponteiro ou null. C23 também exige null se o produto `nmemb * size` desse wrap em `size_t`.
`call_once(flag, func)` usa um `once_flag` para chamar `func` exatamente uma vez, na primeira chamada efetiva com esse objeto, e não devolve valor. A conclusão sincroniza com todas as outras chamadas da mesma flag: as já em curso à espera de `func` e as posteriores.
`cbrt(x)` de `<math.h>` recebe um `double` e devolve a raiz cúbica real; `cbrtf` e `cbrtl` são as formas para `float` e `long double`. Um argumento negativo tem resultado real negativo.
`ceil(x)` de `<math.h>` devolve o menor valor inteiro não inferior a `double x`, ainda representado como `double`; `ceilf` e `ceill` preservam `float` e `long double`. É arredondamento para infinito positivo.
`clearerr(stream)` de `<stdio.h>` limpa tanto o indicador de fim de ficheiro como o indicador de erro do fluxo `FILE` indicado; não devolve valor. Não executa qualquer operação de entrada ou saída.
`clock()` de `<time.h>` devolve a melhor aproximação disponível do tempo de processador consumido ativamente pelo programa desde uma época ligada à invocação mas definida pela implementação. O resultado é `clock_t`; divide por `CLOCKS_PER_SEC` para obter segundos.
`cnd_broadcast(cond)` de `<threads.h>` desbloqueia todas as threads bloqueadas nessa variável de condição no momento da chamada. Sem threads à espera não faz nada; devolve `thrd_success` ou `thrd_error` se o pedido não puder ser cumprido.
`cnd_destroy(cond)` liberta todos os recursos de uma variável de condição anteriormente inicializada e não devolve valor. C23 exige que nenhuma thread esteja bloqueada à espera no momento da chamada.