C`cnd_init(cond)` cria uma nova variável de condição e, no sucesso, guarda em `*cond` um valor que a identifica univocamente. Devolve `thrd_success`, `thrd_nomem` se não puder alocar memória ou `thrd_error` se o pedido não puder ser cumprido.
Intermédio · C23C`cnd_signal(cond)` desbloqueia uma thread bloqueada em `cond` no momento da chamada. Sem threads à espera não faz nada e ainda devolve `thrd_success`; caso contrário devolve `thrd_success` ou `thrd_error`.
Avançado · C23C`cnd_timedwait(cond, mtx, ts)` desbloqueia atomicamente o `mtx` possuído e espera sinal/broadcast, a hora civil absoluta `TIME_UTC` em `*ts` ou desbloqueio por motivo não especificado. Antes do retorno normal bloqueia novamente o mutex.
Avançado · C23C`cnd_wait(cond, mtx)` de `<threads.h>` desbloqueia atomicamente o `mtx` possuído e bloqueia até sinal, broadcast ou desbloqueio por motivo não especificado. Antes de voltar bloqueia novamente `mtx`; devolve `thrd_success` ou `thrd_error`.
Avançado · C23C`copysign(x, y)` de `<math.h>` devolve a magnitude de `x` com o sinal de `y`; se `x` for NaN, resulta um NaN com o sinal de `y`. Se qualquer valor for unsigned, C23 torna o eventual sinal do resultado definido pela implementação.
Intermédio · C23C`cos(x)` de `<math.h>` calcula o cosseno de `x` medido em radianos e devolve `double`; `cosf` e `cosl` servem `float` e `long double`. Para argumentos finitos, o C23 base não especifica erro de domínio.
Básico · C23C`cosh(x)` de `<math.h>` devolve o cosseno hiperbólico de `x`, matematicamente `(e^x + e^-x) / 2`. A função é par; C23 exige erro de intervalo se a magnitude do `x` finito for demasiado grande.
Intermédio · C23C`ctime(timer)` de `<time.h>` converte o tempo de calendário `time_t` apontado numa cadeia de hora local e devolve o ponteiro do equivalente `asctime(localtime(timer))`. Em C23 é declarada `[[deprecated]]`; é obsoleta e deve ser evitada em código novo.
Intermédio · C23C`difftime(time1, time0)` de `<time.h>` calcula `time1 - time0` para dois tempos de calendário `time_t` e devolve a diferença em segundos como `double`. É a interface portável porque a codificação de `time_t` não é especificada.
Intermédio · C23C`div(numer, denom)` de `<stdlib.h>` calcula em conjunto quociente inteiro e resto, devolvendo `div_t` com `quot` e `rem`. A divisão inteira trunca para zero e `numer == quot * denom + rem`.
Básico · C23C`errno` de `<errno.h>` é uma macro que expande para um lvalue modificável do tipo `int` com duração de armazenamento da thread. Não é função nem constante: usa `errno`, nunca `errno()`, e cada thread tem o seu objeto.
Intermédio · C23C`exit(status)` de `<stdlib.h>` causa terminação normal e não volta. Primeiro chama as funções `atexit` pela ordem inversa de registo, depois descarrega e fecha streams, remove ficheiros `tmpfile` e finalmente devolve o estado ao ambiente anfitrião.
Avançado · C23C`exp(x)` de `<math.h>` calcula a exponencial de base e e devolve `e^x` como `double`; `expf` e `expl` servem `float` e `long double`. C23 exige erro de intervalo se a magnitude do `x` finito for demasiado grande.
Intermédio · C23C`exp2(x)` de `<math.h>` calcula `2^x` e devolve-o como `double`; `exp2f` e `exp2l` aceitam, respetivamente, `float` e `long double`. C23 assinala erro de intervalo quando a magnitude do `x` finito é demasiado grande.
Intermédio · C23C`expm1(x)` de `<math.h>` calcula `e^x - 1` como `double`; `expm1f` e `expm1l` servem `float` e `long double`. Conserva precisão para `x` minúsculo, onde avaliar separadamente `exp(x) - 1` perde dígitos ao subtrair valores próximos.
Intermédio · C23C`fabs(x)` de `<math.h>` devolve o valor absoluto de um `double`; `fabsf` e `fabsl` servem `float` e `long double`. Ao contrário de `abs` inteiro, não tem o problema da contraparte positiva não representável do menor inteiro.
Básico · C23C`fclose(stream)` de `<stdio.h>` descarrega o fluxo indicado, entrega os dados não escritos ao ambiente anfitrião, descarta entrada não lida, fecha o ficheiro associado e desassocia o objeto `FILE`. Devolve zero no sucesso ou `EOF` na falha.
Intermédio · C23C`feof(stream)` de `<stdio.h>` testa o indicador de fim de ficheiro de um fluxo `FILE` aberto. Devolve valor não zero se e só se esse indicador estiver definido; não lê dados nem devolve por si a constante `EOF`.
Básico · C23C`ferror(stream)` de `<stdio.h>` testa o indicador de erro de um fluxo `FILE` aberto. Devolve valor não zero se e só se estiver definido; não executa E/S, não fornece um código de erro específico nem altera o estado do fluxo.
Básico · C23C`fflush(stream)` de `<stdio.h>` entrega ao ambiente anfitrião os dados de saída em buffer ainda não escritos de um fluxo de saída ou atualização admissível. `fflush(NULL)` tenta fazê-lo para todos esses fluxos abertos; devolve zero no sucesso ou `EOF` com indicador de erro na falha.
Intermédio · C23C`fgetc(stream)` de `<stdio.h>` lê o caráter seguinte de um fluxo de entrada, avança a posição e devolve o byte interpretado como `unsigned char` e depois convertido em `int`. No fim do ficheiro ou em falha devolve `EOF` e define o indicador correspondente.
Básico · C23C`fgetpos(stream, pos)` de `<stdio.h>` guarda o estado de posição atual de um fluxo aberto no objeto `fpos_t` indicado por `pos`. Devolve zero no sucesso e valor não zero na falha; o estado destina-se a um `fsetpos` posterior.
Intermédio · C23C`fgets(s, n, stream)` de `<stdio.h>` lê no máximo `n - 1` carateres para o array `s`, parando depois de ler nova linha ou no fim do ficheiro. A nova linha lida fica no array e a função acrescenta depois `\0`.
Básico · C23C`floor(x)` de `<math.h>` devolve o maior valor flutuante inteiro não superior a `x`; o resultado continua `double`. `floorf` e `floorl` servem `float` e `long double`, sem depender do modo de arredondamento do ambiente.
Básico · C23