C`cnd_init(cond)` crea una variable de condición nueva y, si tiene éxito, guarda en `*cond` un valor que la identifica de forma única. Devuelve `thrd_success`, `thrd_nomem` si no puede asignar memoria o `thrd_error` si no puede atender la solicitud.
Intermedio · C23C`cnd_signal(cond)` desbloquea un hilo bloqueado en `cond` en el momento de la llamada. Si no hay esperas, no hace nada y aun así devuelve `thrd_success`; en otro caso devuelve `thrd_success` o `thrd_error`.
Avanzado · C23C`cnd_timedwait(cond, mtx, ts)` desbloquea atómicamente el `mtx` poseído y espera señal/broadcast, la hora civil absoluta `TIME_UTC` de `*ts` o un desbloqueo por motivo no especificado. Antes del retorno normal vuelve a bloquear el mutex.
Avanzado · C23C`cnd_wait(cond, mtx)` de `<threads.h>` desbloquea atómicamente el `mtx` poseído y bloquea hasta señal, broadcast o desbloqueo por motivo no especificado. Antes de volver bloquea `mtx` otra vez; devuelve `thrd_success` o `thrd_error`.
Avanzado · C23C`copysign(x, y)` de `<math.h>` devuelve la magnitud de `x` con el signo de `y`; si `x` es NaN, resulta un NaN con el signo de `y`. Si cualquiera de los valores es sin signo, C23 deja el signo eventual del resultado definido por la implementación.
Intermedio · C23C`cos(x)` de `<math.h>` calcula el coseno de `x` medido en radianes y devuelve `double`; `cosf` y `cosl` sirven para `float` y `long double`. Para argumentos finitos, C23 base no especifica error de dominio.
Básico · C23C`cosh(x)` de `<math.h>` devuelve el coseno hiperbólico de `x`, matemáticamente `(e^x + e^-x) / 2`. Es una función par; C23 exige error de rango si la magnitud del `x` finito es demasiado grande.
Intermedio · C23C`ctime(timer)` de `<time.h>` convierte el tiempo de calendario `time_t` señalado en una cadena de hora local y devuelve el puntero del equivalente `asctime(localtime(timer))`. En C23 se declara `[[deprecated]]`; es obsoleta y debe evitarse en código nuevo.
Intermedio · C23C`difftime(time1, time0)` de `<time.h>` calcula `time1 - time0` para dos tiempos de calendario `time_t` y devuelve la diferencia en segundos como `double`. Es la interfaz portable porque la codificación de `time_t` no está especificada.
Intermedio · C23C`div(numer, denom)` de `<stdlib.h>` calcula juntos cociente entero y resto, devolviendo `div_t` con `quot` y `rem`. La división entera trunca hacia cero y `numer == quot * denom + rem`.
Básico · C23C`errno` de `<errno.h>` es un macro que se expande a un lvalue modificable de tipo `int` con duración de almacenamiento de hilo. No es función ni constante: usa `errno`, nunca `errno()`, y cada hilo tiene su propio objeto.
Intermedio · C23C`exit(status)` de `<stdlib.h>` causa terminación normal y no retorna. Primero llama funciones `atexit` en orden inverso de registro; después vacía y cierra flujos, elimina archivos `tmpfile` y finalmente devuelve el estado al entorno anfitrión.
Avanzado · C23C`exp(x)` de `<math.h>` calcula la exponencial de base e y devuelve `e^x` como `double`; `expf` y `expl` sirven para `float` y `long double`. C23 exige error de rango si la magnitud del `x` finito es demasiado grande.
Intermedio · C23C`exp2(x)` de `<math.h>` calcula `2^x` y lo devuelve como `double`; `exp2f` y `exp2l` aceptan `float` y `long double`, respectivamente. C23 señala un error de rango si la magnitud del `x` finito es demasiado grande.
Intermedio · C23C`expm1(x)` de `<math.h>` calcula `e^x - 1` como `double`; `expm1f` y `expm1l` sirven para `float` y `long double`. Conserva precisión con `x` diminuto, donde evaluar por separado `exp(x) - 1` pierde cifras al restar valores cercanos.
Intermedio · C23C`fabs(x)` de `<math.h>` devuelve el valor absoluto de un `double`; `fabsf` y `fabsl` sirven para `float` y `long double`. A diferencia del `abs` entero, no sufre el problema del homólogo positivo no representable del entero mínimo.
Básico · C23C`fclose(stream)` de `<stdio.h>` vacía el flujo indicado, entrega los datos no escritos al entorno anfitrión, descarta la entrada no leída, cierra el archivo asociado y desasocia el objeto `FILE`. Devuelve cero al tener éxito o `EOF` al fallar.
Intermedio · C23C`feof(stream)` de `<stdio.h>` comprueba el indicador de fin de archivo de un flujo `FILE` abierto. Devuelve un valor distinto de cero si y solo si el indicador está fijado; no lee datos ni devuelve por sí misma la constante `EOF`.
Básico · C23C`ferror(stream)` de `<stdio.h>` comprueba el indicador de error de un flujo `FILE` abierto. Devuelve un valor distinto de cero si y solo si está fijado; no realiza E/S, no entrega un código de error concreto ni altera el estado del flujo.
Básico · C23C`fflush(stream)` de `<stdio.h>` entrega al entorno anfitrión los datos de salida no escritos de un flujo de salida o actualización admisible. `fflush(NULL)` lo intenta para todos esos flujos abiertos; devuelve cero al tener éxito o `EOF` con el indicador de error fijado al fallar.
Intermedio · C23C`fgetc(stream)` de `<stdio.h>` lee el siguiente carácter de un flujo de entrada, avanza la posición y devuelve el byte interpretado como `unsigned char` y después convertido a `int`. Al terminar el archivo o fallar devuelve `EOF` y fija el indicador correspondiente.
Básico · C23C`fgetpos(stream, pos)` de `<stdio.h>` guarda el estado de posición actual de un flujo abierto en el objeto `fpos_t` indicado por `pos`. Devuelve cero al tener éxito y un valor distinto de cero al fallar; el estado se destina a un `fsetpos` posterior.
Intermedio · C23C`fgets(s, n, stream)` de `<stdio.h>` lee como máximo `n - 1` caracteres en el array `s`, deteniéndose después de leer un salto de línea o al terminar el archivo. El salto leído queda en el array y la función añade después `\0`.
Básico · C23C`floor(x)` de `<math.h>` devuelve el mayor valor flotante entero que no supera `x`; el resultado sigue siendo `double`. `floorf` y `floorl` sirven para `float` y `long double`, y el modo de redondeo del entorno no cambia el contrato.
Básico · C23