Array a lunghezza variabile (VLA) in C
La lunghezza del buffer locale `int tmp[n]` si determina a tempo di esecuzione. Controllala prima della dichiarazione e tieni conto della vita dell’array e del supporto facoltativo dei VLA automatici in C23.
CKTIS / Base di conoscenza
Sintassi, operatori e concetti di programmazione. Trova una spiegazione, consulta un esempio e torna a imparare.
La lunghezza del buffer locale `int tmp[n]` si determina a tempo di esecuzione. Controllala prima della dichiarazione e tieni conto della vita dell’array e del supporto facoltativo dei VLA automatici in C23.
Dichiara puntatori a funzione, interpreta le parentesi di raggruppamento e riconosci le funzioni che restituiscono questi puntatori.
L’operatore unario * si riferisce all’oggetto o alla funzione indicati da un puntatore. Non crea un oggetto e non alloca memoria.
La funzione abort() di <stdlib.h> avvia una terminazione anomala del programma e non ritorna mai al chiamante.
La funzione abs di <stdlib.h> restituisce il valore assoluto come int. La chiamata abs(INT_MIN) ha un comportamento indefinito.
La funzione acos di <math.h> calcola il valore principale dell’arcocoseno di un argomento double. Il risultato è un angolo in radianti, non in gradi.
La funzione acosh di <math.h> calcola il coseno iperbolico inverso non negativo. Accetta e restituisce un valore double; un argomento minore di 1 causa un errore di dominio.
aligned_alloc alloca memoria non inizializzata con l’allineamento richiesto. Controlla che il risultato non sia NULL e libera la memoria con free.
asctime converte una struct tm in testo a formato fisso. In C23 la funzione è obsoleta e va evitata nel nuovo codice.
La funzione asin di <math.h> calcola il valore principale dell’arcoseno di un argomento double e restituisce un angolo in radianti.
asinh di <math.h> calcola il seno iperbolico inverso di un argomento double e restituisce un valore double. Il suo dominio matematico comprende tutti i numeri reali.
La macro `assert(...)` di `<assert.h>` controlla un’espressione scalare: se vera non fa nulla, se falsa stampa una diagnosi e chiama `abort()`. Non restituisce un valore.
`atan(double x)` di `<math.h>` restituisce l’arcotangente principale in radianti nell’intervallo da `-π/2` a `π/2`; il dominio comprende tutti i numeri reali.
`atan2(double y, double x)` di `<math.h>` restituisce l’angolo direzionale del punto `(x, y)` rispetto all’asse x positivo, in radianti tra `-π` e `π`. Gli argomenti sono nell’ordine `y`, poi `x`.
`atanh(double x)` di `<math.h>` restituisce il valore reale principale della tangente iperbolica inversa. Per un risultato reale finito, l’argomento deve appartenere all’intervallo aperto `(-1, 1)`.
`atexit(void (*func)(void))` di `<stdlib.h>` registra una funzione senza argomenti da chiamare durante la terminazione normale. Restituisce zero al successo e un valore non zero se la registrazione fallisce.
`atof(const char *nptr)` di `<stdlib.h>` converte la parte iniziale di una stringa in `double`; si comporta come `strtod(nptr, NULL)`, ma non offre un puntatore finale utile né una diagnostica affidabile.
`atoi(const char *nptr)` di `<stdlib.h>` converte l’intero decimale iniziale di una stringa e restituisce `int`. Salta gli spazi iniziali, accetta un segno facoltativo e si ferma al primo carattere estraneo al numero.
`atol(const char *nptr)` di `<stdlib.h>` legge l’intero decimale iniziale e restituisce `long int`. Salta gli spazi, accetta un segno facoltativo e si ferma al primo carattere esterno al numero.
`atoll(const char *nptr)` di `<stdlib.h>` converte l’intero decimale iniziale e restituisce `long long int`. Salta gli spazi, riconosce un segno facoltativo e termina al primo carattere non corrispondente.
`atomic_compare_exchange_strong(object, expected, desired)` di `<stdatomic.h>` confronta atomicamente l’atomico `*object` con il non atomico `*expected`. Se uguali memorizza `desired` e restituisce `true`; altrimenti scrive il valore corrente in `*expected` e restituisce `false`, senza fallimenti spuri.
`atomic_compare_exchange_weak(object, expected, desired)` ha la stessa scrittura al successo e lo stesso aggiornamento di `*expected` al fallimento di `strong`, ma può restituire `false` in modo spurio anche con valori uguali. La read-modify-write su `object` resta atomica; la scrittura in `expected` al fallimento è una normale scrittura non atomica.
`atomic_exchange(object, desired)` di `<stdatomic.h>` esegue un’unica operazione atomica read-modify-write: memorizza `desired` in `*object` e restituisce il valore presente immediatamente prima dello scambio.
`atomic_fetch_add(object, operand)` di `<stdatomic.h>` aggiunge atomicamente `operand` a un oggetto intero o puntatore atomico e restituisce il valore precedente. È un’unica operazione read-modify-write.