atomic_fetch_and — función genérica atómica de C23
`atomic_fetch_and(object, operand)` de `<stdatomic.h>` realiza atómicamente `*object &= operand` sobre un tipo entero atómico y devuelve el valor anterior. Es una única operación read-modify-write.
CKTIS / C
Sintaxis, operadores y conceptos de programación. Encuentra una explicación, consulta un ejemplo y sigue aprendiendo.
`atomic_fetch_and(object, operand)` de `<stdatomic.h>` realiza atómicamente `*object &= operand` sobre un tipo entero atómico y devuelve el valor anterior. Es una única operación read-modify-write.
`atomic_fetch_or(object, operand)` de `<stdatomic.h>` realiza atómicamente `*object |= operand` sobre un tipo entero atómico y devuelve el valor anterior a activar los bits. Es una única operación read-modify-write.
`atomic_fetch_sub(object, operand)` de `<stdatomic.h>` resta atómicamente `operand` de un objeto entero o puntero atómico y devuelve el valor anterior. Es una única operación read-modify-write.
`atomic_fetch_xor(object, operand)` de `<stdatomic.h>` realiza atómicamente `*object ^= operand` sobre un tipo entero atómico y devuelve el valor anterior a invertir los bits. Es una única operación read-modify-write.
`atomic_flag_clear(object)` de `<stdatomic.h>` coloca atómicamente el `atomic_flag` apuntado en estado limpio y no devuelve valor. La forma básica usa `memory_order_seq_cst`.
`atomic_flag_test_and_set(object)` de `<stdatomic.h>` activa atómicamente un `atomic_flag` y devuelve su estado anterior: `false` significa que adquirió una bandera antes limpia y `true` que ya estaba activa.
`atomic_init(obj, value)` de `<stdatomic.h>` inicializa el objeto atómico apuntado con `value`, incluido cualquier estado adicional de la implementación, y no devuelve valor. Si el almacenamiento no tiene tipo declarado, la llamada le da el tipo efectivo atómico `A`.
`atomic_load(object)` devuelve atómicamente el valor del objeto atómico apuntado. La forma sin `_explicit` equivale a `atomic_load_explicit(..., memory_order_seq_cst)`; el `volatile` del puntero conserva la semántica de registros de dispositivo.
`atomic_signal_fence(order)` establece restricciones de orden solo entre el código del hilo y un manejador de señal ejecutado en ese mismo hilo. Tiene las clases de orden de `atomic_thread_fence`, no devuelve valor y no es genérica.
`atomic_store(object, desired)` sustituye atómicamente el valor del objeto apuntado por `desired` y no devuelve valor. La forma sin `_explicit` usa `memory_order_seq_cst`; es una escritura, no una operación read-modify-write.
`atomic_thread_fence(order)` establece una barrera de memoria sin leer ni escribir un átomo concreto. Relaxed no tiene efecto; consume/acquire crea barrera acquire, release una release, acq_rel ambas y seq_cst además participa en el orden secuencialmente consistente. No devuelve valor.
at_quick_exit, de <stdlib.h>, registra una función que quick_exit llama. Devuelve 0 si tiene éxito y un valor distinto de cero si falla.
`bsearch(key, base, nmemb, size, compar)` busca entre `nmemb` objetos de `size` bytes y devuelve un puntero a un elemento igual a `key`, o null. El comparador recibe primero la clave y luego el elemento, y devuelve valor negativo, cero o positivo.
`c16rtomb(s, c16, ps)` convierte una unidad `char16_t` codificada como UTF-16 a la representación multibyte del `LC_CTYPE` actual, guarda como máximo `MB_CUR_MAX` bytes y devuelve el número guardado, incluidas secuencias de desplazamiento.
`c32rtomb(s, c32, ps)` convierte una unidad `char32_t` codificada como UTF-32 a la representación multibyte del `LC_CTYPE` actual, guarda como máximo `MB_CUR_MAX` bytes y devuelve el número guardado, incluidas secuencias de desplazamiento.
`c8rtomb(s, c8, ps)` convierte una unidad `char8_t` codificada como UTF-8 a la representación multibyte del `LC_CTYPE` actual, guarda como máximo `MB_CUR_MAX` bytes y devuelve el número guardado, incluidas secuencias de desplazamiento.
`calloc(nmemb, size)` de `<stdlib.h>` asigna un array de `nmemb` objetos de `size` bytes, pone a cero todos los bits de la región y devuelve su puntero o null. C23 también exige null si el producto `nmemb * size` desbordaría `size_t`.
`call_once(flag, func)` usa un `once_flag` para llamar a `func` exactamente una vez, en la primera llamada efectiva con ese objeto, y no devuelve valor. Su finalización sincroniza con todas las demás llamadas de la misma bandera: las ya en curso que esperan a `func` y las posteriores.
`cbrt(x)` de `<math.h>` recibe un `double` y devuelve su raíz cúbica real; `cbrtf` y `cbrtl` son las formas para `float` y `long double`. Un argumento negativo da un resultado real negativo.
`ceil(x)` de `<math.h>` devuelve el menor valor entero no inferior a `double x`, aún representado como `double`; `ceilf` y `ceill` conservan `float` y `long double`. Es redondeo hacia infinito positivo.
`clearerr(stream)` de `<stdio.h>` borra tanto el indicador de fin de archivo como el indicador de error del flujo `FILE` indicado; no devuelve valor. No realiza ninguna operación de entrada o salida.
`clock()` de `<time.h>` devuelve la mejor aproximación disponible del tiempo de procesador consumido activamente por el programa desde una época relacionada con su invocación pero definida por la implementación. El resultado es `clock_t`; divídelo por `CLOCKS_PER_SEC` para obtener segundos.
`cnd_broadcast(cond)` de `<threads.h>` desbloquea todos los hilos bloqueados en esa variable de condición en el momento de la llamada. Sin esperas no hace nada; devuelve `thrd_success` o `thrd_error` si no puede atender la solicitud.
`cnd_destroy(cond)` libera todos los recursos de una variable de condición inicializada previamente y no devuelve valor. C23 exige que ningún hilo esté bloqueado esperándola al llamar.