Libreria standard Concetti chiave

Transcript

1 Libreria standard B Concetti chiave File d intestazione standard Diagnostica Numeri complessi Controllo e conversione di caratteri Segnalazioni di errore Ambiente in virgola mobile Caratteristiche dei tipi in virgola mobile Tipi interi Spelling alternativo Limiti numerici dell ambiente di esecuzione Parametri di localizzazione Funzioni matematiche in doppia precisione Salti non locali Gestione segnali Gestione lista di argomenti variabili in numero e tipo Definizioni standard Interi Input e Output Utilità generale Gestione di stringhe Matematica dei tipi generici Gestione della data e dell ora Utility per caratteri estesi e multibyte Utility per la configurazione dei caratteri estesi

2 A02w2 / Appendice B Libreria standard Per utilizzare una funzione di libreria si deve includere, con la direttiva del preprocessore #include, l header in cui è dichiarata. #include <nomefile> Ogni header, o file d intestazione, contiene dichiarazioni prototype di un insieme di funzioni correlate nonché della macro e dei tipi dati necessari al loro uso. Invece le definizioni delle funzioni sono a carico e quindi dipendono dalle differenti implementazioni. Gli header previsti dallo standard sono: <assert.h> <limits.h> <stdbool.h> <threads.h> <complex.h> <locale.h> <stddef.h> <time.h> <ctype.h> <math.h> <stdint.h> <uchar.h> <errno.h> <setjmp.h> <stdio.h> <wchar.h> <fenv.h> <signal.h> <stdlib.h> <wctype.h> <float.h> <stdalign.h> <stdnoreturn.h> <inttypes.h> <stdarg.h> <string.h> <iso646.h> <stdatomic.h> <tgmath.h> Di seguito riportiamo una breve descrizione di ogni libreria standard, accompagnata dal riferimento ai capitoli dove è trattata nel testo. Il documento di riferimento da cui sono stati tratti i contenuti è l ISO/IEC 9899:2011. <assert.h> Diagnostica Comprende: NDEBUG static_assert e la dichiarazione della macro che aiuta la diagnostica dei programmi: void assert(scalare espressione) Attenzione: si tratta di una macro, non di una fuzione. Lo standard indica con scalare un tipo numerico intero, se l implementazione utilizza per il tipo un int si ha void assert(int espressione). In fase di esecuzione se espressione è falsa, cioè espressione è uguale a zero, assert scrive sullo standard error, per esempio il video, delle informazioni utili per la diagnostica del programma quali: l argomento della assert (il testo di espressione), il nome del file sorgente e il numero di riga del file sorgente; questi ultimi sono rispettivamente i valori delle macro FILE e LINE. Viene poi richiamata la funzione abort dichiarata in stdlib.h che termina l esecuzione del programma. Se la direttiva #NDEBUG (No Debug) è presente nel file sorgente in cui è inclusa <assert.h> la macro assert non ha alcun effetto, infatti è espansa in #define assert(ignore) ((void)0), dunque la macro è ridefinita in base alla presenza o meno di NDEBUG. Si veda il Capitolo 24 per l uso di assert, il Capitoli 23 per FILE, LI- NE e le macroistruzioni in generale, il Capitolo 17 per lo standard error.

3 Libreria standard / A02w3 <complex.h> Numeri complessi Contiene la dichiarazione di funzioni e la definizione di macro che supportano l aritmetica dei numeri complessi. STDC_NO_COMPLEX imaginary complex _Imaginary_I _Complex_I I Le implementazioni che definiscono la macro STDC_NO_COMPLEX non hanno la necessità di fornire questo file di intestazione e non supportano le funzionalità di complex.h. La macro complex è espansa in _Complex. La macro _Complex_I che è espansa in un espressione costante di tipo const float _Complex, con il valore dell unità immaginaria. Le macro imaginary e _Imaginary_I sono definite se e solo se l implementazione supporta i tipi immaginari, se sono definite sono espanse in Imaginary e in un espressione costante di tipo const float _Imaginary con il valore dell unità immaginaria. La macro I si espande in _Imaginary_I o in _Complex_I. Se _Imaginary_I non è definito, I si deve espandere in _Complex_I. #pragma STDC CX_LIMITED_RANGE on-off-switch Le usuali formule matematiche sui valori complessi presentano delle criticità a causa degli overflow che si possono produrre nel calcolo di moltiplicazioni, divisioni e valori assoluti. La direttiva è usata per informare l implementazione, nel caso di on, che possono essere utilizzate le usuali formule matematiche. Il default è off. double complex cacos(double complex z) Arcocoseno complesso di z con dei punti di diramazione al di fuori dell intervallo [-1,+1] lungo l asse reale. Il valore restituito risiede nella striscia priva di confini lungo l asse immaginario e delimitata dall intervallo [0, π] lungo l asse reale. La "c" iniziale nel nome di tutte le funzioni della libreria sta per complesso. double complex casin(double complex z) Arcoseno (sine) complesso di z con i punti di diramazione al di fuori dell intervallo [-1,+1] lungo l asse reale. Il valore restituito risiede su una striscia priva di confini lungo l asse immaginario e delimitata dall intervallo [-π /2, + π /2] lungo l asse reale. double complex catan(double complex z) Arctangente complessa di z, con i punti di diramazione al di fuori dell intervallo [-i, +i] lungo l asse immaginario. Il valore restituito risiede su una striscia priva di confini lungo l asse immaginario e delimitata dall intervallo [-π /2,+ π /2] lungo l asse reale. double complex ccos(double complex z) Coseno complesso di z. double complex csin(double complex z) Seno complesso di z.

4 A02w4 / Appendice B double complex ctan(double complex z) Tangente complessa di z. double complex cacosh(double complex z) Arcocoseno iperbolico (sine hyperbolic) complesso di z, con un punto di diramazione ai valori minori di 1 lungo l asse reale. Il valore restituito risiede nella semistriscia dei valori non negativi lungo l asse reale e nell intervallo [-i π, +i π] lungo l asse immaginario. double complex casinh(double complex z) Arcoseno iperbolico (hyperbolic) complesso di z, con dei punti di diramazione al di fuori dell intervallo [-i, +i] lungo l asse immaginario. Il valore restituito risiede su una striscia priva di confini lungo l asse reale e delimitata dall intervallo [-i π/2, +i π/2] lungo l asse immaginario. double complex catanh(double complex z) Arcotangente iperbolico (hyperbolic) complessa di z, con dei punti di diramazione al di fuori dell intervallo [-1, +1] lungo l asse reale. Il valore restituito risiede su una striscia priva di confini lungo l asse reale e delimitata dall intervallo [-i π/2, +i π/2] lungo l asse immaginario. double complex ccosh(double complex z) Coseno iperbolico complesso di z. double complex csinh(double complex z) Seno iperbolico complesso di z. double complex ctanh(double complex z) Tangente iperbolica complessa di z. double complex cexp(double complex z) Esponenziale complesso di e in base z. double complex clog(double complex z) Logaritmo naturale (base e) di z, con un punto di diramazione lungo l asse reale negativo. Il valore restituito risiede su una striscia priva di confini lungo l asse reale e delimitata dall intervallo [-iπ, +iπ] lungo l asse immaginario. double cabs(double complex z) Valore assoluto (absolute) complesso di z. double complex cpow(double complex x, double complex y) x elevato alla potenza di y, con un punto di ramificazione per il primo parametro lungo la porzione negativa dell asse reale. double complex csqrt(double complex z) Radice quadrata complessa di z, con punto di diramazione lungo la parte negativa dell asse reale. double carg(double complex z) Calcola l argomento (angolo di fase) di z, con un punto di diramazione lungo l asse immaginario negativo. Il valore restituito risiede nell intervallo [-π, +π]. double cimag(double complex z)

5 Libreria standard / A02w5 Restituiscono la parte immaginaria di z. double complex CMPLX(double x, double y) È una macro espansa in un espressione di tipo double complesso, con la parte reale che ha il valore (convertito) di x e la parte immaginaria che ha il valore (convertito) di y. double complex conj(double complex z) Restituisce il coniugato complesso di z. double complex cproj(double complex z) Restituisce la proiezione di z sulla sfera di Riemann. Viene restituito z a meno che una delle sue parti non sia infinita, in tal caso il valore restituito è IN- FINITY+I*copysign(0.0,cimag(z)). La macro INFINITY è espansa a un espressione constante che rappresenta un valore infinito, Le funzioni cpoysign restituisce il valore assoluto di x e il segno di y, per entrambe si veda math.h. double creal(double complex z) Restituisce la parte reale proiezione di z. Segue l elenco di tutte le funzioni. double complex cacos(double complex z); float complex cacosf(float complex z); long double complex cacosl(long double complex z); double complex casin(double complex z); float complex casinf(float complex z); long double complex casinl(long double complex z); double complex catan(double complex z); float complex catanf(float complex z); long double complex catanl(long double complex z); double complex ccos(double complex z); float complex ccosf(float complex z); long double complex ccosl(long double complex z); double complex csin(double complex z); float complex csinf(float complex z); long double complex csinl(long double complex z); double complex ctan(double complex z); float complex ctanf(float complex z); long double complex ctanl(long double complex z); double complex cacosh(double complex z); float complex cacoshf(float complex z); long double complex cacoshl(long double complex z); double complex casinh(double complex z); float complex casinhf(float complex z); long double complex casinhl(long double complex z);

6 A02w6 / Appendice B double complex catanh(double complex z); float complex catanhf(float complex z); long double complex catanhl(long double complex z); double complex ccosh(double complex z); float complex ccoshf(float complex z); long double complex ccoshl(long double complex z); double complex csinh(double complex z); float complex csinhf(float complex z); long double complex csinhl(long double complex z); double complex ctanh(double complex z); float complex ctanhf(float complex z); long double complex ctanhl(long double complex z); double complex cexp(double complex z); float complex cexpf(float complex z); long double complex cexpl(long double complex z); double complex clog(double complex z); float complex clogf(float complex z); long double complex clogl(long double complex z); double cabs(double complex z); float cabsf(float complex z); long double cabsl(long double complex z); double complex cpow(double complex x, double complex y); float complex cpowf(float complex x, float complex y); long double complex cpowl(long double complex x, long double complex y); double complex csqrt(double complex z); float complex csqrtf(float complex z); long double complex csqrtl(long double complex z); double carg(double complex z); float cargf(float complex z); long double cargl(long double complex z); double cimag(double complex z); float cimagf(float complex z); long double cimagl(long double complex z); double complex CMPLX(double x, double y); float complex CMPLXF(float x, float y); long double complex CMPLXL(long double x, long double y); double complex conj(double complex z); float complex conjf(float complex z); long double complex conjl(long double complex z); double complex cproj(double complex z);

7 Libreria standard / A02w7 float complex cprojf(float complex z); long double complex cprojl(long double complex z); double creal(double complex z); float crealf(float complex z); long double creall(long double complex z); <ctype.h> Controllo e conversione caratteri Molte funzioni delle libreria restituiscono un valore diverso da zero, vero, se il valore dell argomento c fa parte di un certo insieme di caratteri esplicitati dal nome della funzione stessa. Per esempio: isdigit(c) ritorna un valore diverso da zero se c è una cifra decimale (is a digit); analogamente operano le altre funzioni. int isalnum(int c) È un carattere alfanumerico? Caratteri veri per isalpha o isdigit. int isalpha(int c) È un carattere alfabetico? Caratteri veri per isupper o islower. int isblank(int c) È un carattere standard bianco o è un carattere, compreso in uno specifico insieme di caratteri definito localmente, per cui isspace è vero e che è usato per separare parole su una linea di testo. I caratteri standar bianchi sono lo spazio ' ' e la tabulazione orizzontale '\t'. int iscntrl(int c) È un carattere di controllo? int isdigit(int c) È una cifra decimale? int isgraph(int c) È carattere stampabile (eccetto lo spazio ' ')? int islower(int c) È una lettera minuscola? int isprint(int c) È un carattere stampabile (incluso lo spazio ' ')? int ispunct(int c) È un carattere stampabile (eccetto: spazio ' ', lettera e cifra decimale)? Caratteri non veri per isalnum; isspace(c), spazio bianco standard cioè ' ', '\f', '\n', '\r', '\t', '\v'. int isspace(int c) È uno spazio ' ', '\f', '\n', '\r', '\t', '\v'? int isupper(int c) È una lettera maiuscola? int isxdigit(int c) È una cifra esadecimale?

8 A02w8 / Appendice B Inoltre vi sono dichiarate: int tolower(int c) Converte una lettera maiuscola nella sua corrispondente minuscola se esiste, altrimenti restituisce l argomento inalterato. int toupper(int c) Converte una lettera minuscola nella sua corrispondente maiuscola se esiste, altrimenti restituisce l argomento inalterato. Si vedano soprattutto i Capitoli 5, 6, 7, e 11. <errno.h> Segnalazioni di errore Definisce la variabile errno e le macro EDOM, EILSEQ e ERANGE che si espandono in costanti intere, che rappresentano simbolicamente situazioni di errore. errno Variabile intera. Il valore iniziale che si può leggere da errno è zero (con cui si intende l assenza di qualunque tipo di situazione di errore) e viene modificato dalle funzioni che, di volta in volta, possono avere bisogno di annotare uno stato di errore. EDOM Costante intera. Domain error, errore di dominio: l argomento di una funzione matematica ha un valore al di fuori del dominio previsto. EILSEQ Costante intera. Illegal byte sequence, errore di codifica: la sequenza dei byte che deve rappresentare una certa codifica contiene un errore. ERANGE Costante intera. Range error, errore nell intervallo di valori: il risultato di un espressione matematica non può essere rappresentato nell intervallo di valori previsto (ovvero nella variabile che deve riceverlo). La variabile intera errno può essere utilizzata per il controllo dell errore nella chiamata a quelle funzioni di libreria in cui lo standard documenta l uso di errno. In questo caso il programmatore, prima di una chiamata a una funzione di libreria, dovrebbe assegnarle zero e, prima di chiamarne un altra, controllarne il valore. Se a quel punto il valore di errno è diverso da zero significa che si è verificato un errore in quella funzione. I valori costanti in cui sono espanse le macro EDOM, EILSEQ e ERANGE dipendono dall implementazione, in particolare dalle convenzioni del sistema operativo, lo standard impone soltanto che debbano essere interi positivi distinti. EDOM, EILSEQ e ERANGE sono generalmente utilizzate nelle direttive #if del preprocessore. <errno.h> potrebbe presentarsi così: extern int errno; #define EDOM 33 #define EILSEQ 42 #define ERANGE 34

9 Libreria standard / A02w9 I numeri associati alle macro offrono solo un campione, in altro ambiente per esempio con sistema operativo Linux EILSEQ potrebbe essere 84. Lo standard del linguaggio prescrive poche macro-variabili, da cui dipendono le librerie standard, mentre tutte le altre sono competenza delle convenzioni del sistema operativo. <fenv.h> Ambiente floating-point Floating-point Environment. Rende disponibili funzioni, tipi dato e macro per la gestione dei valori in virgola mobile dell implementazione in uso. fenv_t FE_OVERFLOW FE_TOWARDZERO fexcept_t FE_UNDERFLOW FE_UPWARD FE_DIVBYZERO FE_ALL_EXCEPT FE_DFL_ENV FE_INEXACT FE_DOWNWARD FE_INVALID FE_TONEAREST #pragma STDC FENV_ACCESS on-off-switch La direttiva è usata per informare l implementazione, nel caso di on, che un programma può accedere ai all ambiente floating-point. int feclearexcept(int excepts); int fegetexceptflag(fexcept_t *flagp, int excepts); int feraiseexcept(int excepts); int fesetexceptflag(const fexcept_t *flagp, int excepts); int fetestexcept(int excepts); int fegetround(void); int fesetround(int round); int fegetenv(fenv_t *envp); int feholdexcept(fenv_t *envp); int fesetenv(const fenv_t *envp); int feupdateenv(const fenv_t *envp); <float.h> Caratteristiche dei tipi in virgola mobile Definisce alcune costanti che descrivono gli oggetti in virgola mobile (floating point) nell ambiente specifico. Per ogni tipo floating point vi è specificato il valore massimo (il più grande valore positivo rappresentabile), il valore minimo (il più piccolo valore negativo rappresentabile), epsilon (il minimo numero positivo x per cui x!= 0) e la precisione (il numero di cifre decimali di precisione). Per il tipo float, FLT_MAX, FLT_MIN, FLT_EPSILON e FLT_DIG rappresentano rispettivamente i valori massimo, minimo, epsilon e precisione. FLT_ROUNDS DBL_MIN_EXP FLT_MAX FLT_EVAL_METHOD LDBL_MIN_EXP DBL_MAX FLT_RADIX FLT_MIN_10_EXP LDBL_MAX FLT_MANT_DIG DBL_MIN_10_EXP FLT_EPSILON DBL_MANT_DIG LDBL_MIN_10_EXP DBL_EPSILON LDBL_MANT_DIG FLT_MAX_EXP LDBL_EPSILON DECIMAL_DIG DBL_MAX_EXP FLT_MIN

10 A02w10 / Appendice B FLT_DIG LDBL_MAX_EXP DBL_MIN DBL_DIG FLT_MAX_10_EXP LDBL_MIN LDBL_DIG DBL_MAX_10_EXP FLT_MIN_EXP LDBL_MAX_10_EXP Vediamo alcune costanti più da vicino. Costante Significato Valori FLT_RADIX Base della rappresentazione minimo 2 esponenziale FLT_ROUNDS Modo di arrotondamento in virgola mobile float -1 (indeterminabile), 0 (troncamento), arrotondamento al più vicino, arrotondamento verso l infinito positvo, 3 arrotondamento verso l infinito negativo, altri valori per arrontondamenti definiti dall implementazione FLT_DIG Cifre di precisione decimale Almeno 6 float FLT_EPSILON Il più piccolo x tale che 1.0+x Almeno 10-5 è diverso da zero float FLT_MANT_DIG Numero di cifre della mantissa float FLT_MAX Il massimo numero in virgola Almeno mobile float FLT_MAX_EXP Massimo esponente float FLT_MIN Minimo numero in virgola Almeno mobile float FLT_MIN_EXP Minimo esponente float DBL_DIG Cifre di precisione decimale Almeno 10 double DBL_EPSILON Il più piccolo x tale che 1.0+x Almeno 10-9 è diverso da zero double DBL_MANT_DIG Numero di cifre della mantissa double DBL_MAX Il massimo numero in virgola Almeno mobile double DBL_MAX_EXP Massimo esponente double DBL_MIN Minimo numero double Almeno DBL_MIN_EXP Minimo esponente double Si vedano i Capitoli 6, 18 e l Appendice D, quet ultima consultabile sul sito dedicato al volume. <inttypes.h> Tipi interi Include l header <stdint.h> e lo estende con le facilità fornite dall implementazione. Dichiara funzioni per la manipolazione di interi di grandi dimensioni e la conversione di stringhe di caratteri/numeri. Per ogni tipo dichiarato in

11 Libreria standard / A02w11 <stdint. h> definisce corrispondenti macro per specificare la conversione per l uso con funzioni di input/output formattato. FLT_ROUNDS DBL_DIG FLT_MAX FLT_EVAL_METHOD LDBL_DIG DBL_MAX FLT_HAS_SUBNORM FLT_MIN_EXP LDBL_MAX DBL_HAS_SUBNORM DBL_MIN_EXP FLT_EPSILON LDBL_HAS_SUBNORM LDBL_MIN_EXP DBL_EPSILON FLT_RADIX FLT_MIN_10_EXP LDBL_EPSILON FLT_MANT_DIG DBL_MIN_10_EXP FLT_MIN DBL_MANT_DIG LDBL_MIN_10_EXP DBL_MIN LDBL_MANT_DIG FLT_MAX_EXP LDBL_MIN FLT_DECIMAL_DIG DBL_MAX_EXP FLT_TRUE_MIN DBL_DECIMAL_DIG LDBL_MAX_EXP DBL_TRUE_MIN LDBL_DECIMAL_DIG FLT_MAX_10_EXP LDBL_TRUE_MIN DECIMAL_DIG DBL_MAX_10_EXP FLT_DIG LDBL_MAX_10_EXP <iso646.h> Spelling alternativo Definisce le seguenti undici macro che si espandono nei simboli sulla destra: and && and_eq &= bitand & bitor compl ~ not! not_eq!= or or_eq = xor ^ xor_eq ^= <limits.h> Limiti numerici dell ambiente di esecuzione Fornisce alcune costanti che definiscono l ambiente di esecuzione: CHAR_BIT CHAR_MAX CHAR_MIN INT_MAX INT_MIN LLONG_MAX LLONG_MIN LONG_MAX LONG_MIN MB_LEN_MAX SCHAR_MAX SCHAR_MIN SHRT_MAX SHRT_MIN UCHAR_MAX UINT_MAX ULLONG_MAX ULONG_MAX USHRT_MAX Per esempio, INT_MAX e INT_MIN definiscono rispettivamente il massimo e il minimo valore rappresentabile con un int, LONG_MAX e LONG_MIN con un tipo long int. Vediamo da vicino alcune costanti; sulla destra i valori limite tipici per implementazioni su sistemi a 32 e 64 bits e quanto definito dallo standard. Costante Significato Esempio a 32 bit CHAR_BIT CHAR_MAX Bit di un byte (più precisamente i bit del più piccolo oggetto che non è un campo-bit) Massimo valore di un char Esempio a 64 bit Standard (se un char è rappresentato come un signed char altrimenti +255)

12 A02w12 / Appendice B Costante Significato Esempio a 32 bit CHAR_MIN Minimo valore di un char Esempio a 64 bit Standard (se un char è rappresentato come un signed char altrimenti 0) INT_MAX Massimo valore di int INT_MIN Minimo valore di un int 648 LONG_MAX Massimo valore di un long LONG_MIN Minimo valore di un long SCHAR_MAX Massimo valore di un signed char SCHAR_MIN Minimo valore di un signed char SHRT_MAX Massimo valore di uno short SHRT_MIN Minimo valore di uno short UCHAR_MAX Massimo valore di un unsigned char UINT_MAX Minimo valore di un unsigned int 295 ULONG_MAX Massimo valore di un unsigned long USHRT_MAX Massimo valore di un unsigned short Si vedano soprattutto i Capitoli 6, 18 e l Appendice B, quest ultima consultabile sul sito dedicato al volume. <locale.h> Parametri di localizzazione Gestione di parametri quali il set di caratteri, la moneta, le convenzioni numeriche locali. L obiettivo dello standard è di rendere il linguaggio il più universale possibile. A seconda della localizzazione possono cambiare il set di caratteri (si pensi alle lingue arabe o asiatiche) o anche semplicemente le convenzioni numeriche (si pensi alle differenze nell uso della virgola e del punto decimali). Per rendere il linguaggio universale molte funzioni devono comportarsi in modo diverso in dipendenza della localizzazione. Per esempio, isalph, (si veda sopra nella descrizione dell header ctype.h) restituisce valori diversi a seconda dell insieme di caratteri in uso. Per fare in modo che la funzione possa comportarsi in modo diverso si badi bene: a tempo di esecuzione, non di compilazione, perché la flessibilità sia massima è possibile selezionare una determinata configurazione locale o individuare una configurazione attiva grazie alla funzione setlocale.

13 Libreria standard / A02w13 Al variare di una configurazione locale tutte le funzioni da essa influenzate modificano conseguentemente il proprio comportamento in fase di esecuzione. struct lconv NULL LC_ALL LC_COLLATE LC_CTYPE LC_MONETARY LC_NUMERIC LC_TIME char *setlocale(int category, const char *locale); struct lconv *localeconv(void); <math.h> Funzioni matematiche in doppia precisione Funzioni trigonometriche come le seguenti. double acos(double x) Arcocoseno. Si ha un errore di dominio se l argomento non è nell intervallo [-1, +1]. double acosh(double x) L arcocoseno iperbolico di x, il valore restituito appartiene all intervallo [0 a + ]. Se x è minore di 1 si verifica un errore di dominio. double asin(double x) Arcoseno. Si ha un errore di dominio se l argomento non è nell intervallo [- 1, +1]. double atan(double x) Arcotangente. Il valore di ritonro è nell intervallo [ π/2, +π/2] radianti. double atan2(double y, double x) Arcotangente di y/x. double cos(double x) Coseno di x in radianti. double cosh(double x) Coseno iperbolico. double sin(double x) Seno di x in radianti. double sinh(double x) Seno iperbolico. double sqrt(double x) Radice quadrata di x. double tan(double x) Tangente di x in radianti. double tanh(double x) Tangente iperbolica. Funzioni matematiche come le seguenti. double ceil(double x) Il valore intero più piccolo non minore di x.

14 A02w14 / Appendice B double copysign(double x, double y); Il valore assoluto di x con il segno di y double exp(double x) Esponenziale di x. double fabs(double x) Il valore assoluto di x in virgola mobile. double floor(double x) Il valore intero più grande non maggiore di x. double fmod(double x, double y) Resto in virgola mobile di x/y double hypot(double x, double y); Radice quadrata della somma dei quadrati di x e y. double log(double x) Logaritmo naturale di x. double log10(double x) Logaritmo in base 10 di x. double pow(double x, double y) x elevato alla potenza y. Segue l elenco delle macro e delle funzioni. float_t double_t HUGE_VAL HUGE_VALF HUGE_VALL INFINITY NAN FP_INFINITE FP_NAN FP_NORMAL FP_SUBNORMAL FP_ZERO FP_FAST_FMA FP_FAST_FMAF FP_FAST_FMAL FP_ILOGB0 FP_ILOGBNAN MATH_ERRNO MATH_ERREXCEPT math_errhandling La macro INFINITY è espansa a un espressione constante di tipo float che rappresenta un valore infinito positivo o negativo, se disponibile, altrimento è espansa in una costante positiva di tipo float che genera l overflow. #pragma STDC FP_CONTRACT on-off-switch int fpclassify(real-floating x); int isfinite(real-floating x); int isinf(real-floating x); int isnan(real-floating x); int isnormal(real-floating x); int signbit(real-floating x); double acos(double x); float acosf(float x); long double acosl(long double x);

15 Libreria standard / A02w15 double asin(double x); float asinf(float x); long double asinl(long double x); double atan(double x); float atanf(float x); long double atanl(long double x); double atan2(double y, double x); float atan2f(float y, float x); long double atan2l(long double y, long double x); double cos(double x); float cosf(float x); long double cosl(long double x); double sin(double x); float sinf(float x); long double sinl(long double x); double tan(double x); float tanf(float x); long double tanl(long double x); double acosh(double x); float acoshf(float x); long double acoshl(long double x); double asinh(double x); float asinhf(float x); long double asinhl(long double x); double atanh(double x); float atanhf(float x); long double atanhl(long double x); double cosh(double x); float coshf(float x); long double coshl(long double x); double sinh(double x); float sinhf(float x); long double sinhl(long double x); double tanh(double x); float tanhf(float x); long double tanhl(long double x); double exp(double x); float expf(float x); long double expl(long double x); double exp2(double x);

16 A02w16 / Appendice B float exp2f(float x); long double exp2l(long double x); double expm1(double x); float expm1f(float x); long double expm1l(long double x); double frexp(double value, int *exp); float frexpf(float value, int *exp); long double frexpl(long double value, int *exp); int ilogb(double x); int ilogbf(float x); int ilogbl(long double x); double ldexp(double x, int exp); float ldexpf(float x, int exp); long double ldexpl(long double x, int exp); double log(double x); float logf(float x); long double logl(long double x); double log10(double x); float log10f(float x); long double log10l(long double x); double log1p(double x); float log1pf(float x); long double log1pl(long double x); double log2(double x); float log2f(float x); long double log2l(long double x); double logb(double x); float logbf(float x); long double logbl(long double x); double modf(double value, double *iptr); float modff(float value, float *iptr); long double modfl(long double value, long double *iptr); double scalbn(double x, int n); float scalbnf(float x, int n); long double scalbnl(long double x, int n); double scalbln(double x, long int n); float scalblnf(float x, long int n); long double scalblnl(long double x, long int n); double cbrt(double x); float cbrtf(float x); long double cbrtl(long double x); double fabs(double x);

17 Libreria standard / A02w17 float fabsf(float x); long double fabsl(long double x); double hypot(double x, double y); float hypotf(float x, float y); long double hypotl(long double x, long double y); double pow(double x, double y); float powf(float x, float y); long double powl(long double x, long double y); double sqrt(double x); float sqrtf(float x); long double sqrtl(long double x); double erf(double x); float erff(float x); long double erfl(long double x); double erfc(double x); float erfcf(float x); long double erfcl(long double x); double lgamma(double x); float lgammaf(float x); long double lgammal(long double x); double tgamma(double x); float tgammaf(float x); long double tgammal(long double x); double ceil(double x); float ceilf(float x); long double ceill(long double x); double floor(double x); float floorf(float x); long double floorl(long double x); double nearbyint(double x); float nearbyintf(float x); long double nearbyintl(long double x); double rint(double x); float rintf(float x); long double rintl(long double x); long int lrint(double x); long int lrintf(float x); long int lrintl(long double x); long long int llrint(double x); long long int llrintf(float x); long long int llrintl(long double x);

18 A02w18 / Appendice B double round(double x); float roundf(float x); long double roundl(long double x); long int lround(double x); long int lroundf(float x); long int lroundl(long double x); long long int llround(double x); long long int llroundf(float x); long long int llroundl(long double x); double trunc(double x); float truncf(float x); long double truncl(long double x); double fmod(double x, double y); float fmodf(float x, float y); long double fmodl(long double x, long double y); double remainder(double x, double y); float remainderf(float x, float y); long double remainderl(long double x, long double y); double remquo(double x, double y, int *quo); float remquof(float x, float y, int *quo); long double remquol(long double x, long double y, int *quo); double copysign(double x, double y); float copysignf(float x, float y); long double copysignl(long double x, long double y); double nan(const char *tagp); float nanf(const char *tagp); long double nanl(const char *tagp); double nextafter(double x, double y); float nextafterf(float x, float y); long double nextafterl(long double x, long double y); double nexttoward(double x, long double y); float nexttowardf(float x, long double y); long double nexttowardl(long double x, long double y); double fdim(double x, double y); float fdimf(float x, float y); long double fdiml(long double x, long double y); double fmax(double x, double y); float fmaxf(float x, float y); long double fmaxl(long double x, long double y); double fmin(double x, double y); float fminf(float x, float y); long double fminl(long double x, long double y); double fma(double x, double y, double z);

19 Libreria standard / A02w19 float fmaf(float x, float y, float z); long double fmal(long double x, long double y, long double z); int isgreater(real-floating x, real-floating y); int isgreaterequal(real-floating x, real-floating y); int isless(real-floating x, real-floating y); int islessequal(real-floating x, real-floating y); int islessgreater(real-floating x, real-floating y); int isunordered(real-floating x, real-floating y); Si vedano i Capitoli 6 e 11. <setjmp.h> Salti non locali Contiene la dichiarazione di funzioni che permettono di alterare l esecuzione della normale sequenza di chiamata e uscita di una funzione, per esempio per obbligare a un ritorno immediato da una chiamata di funzione profondamente annidata. jmp_buf int setjmp(jmp_buf env); _Noreturn void longjmp(jmp_buf env, int val); <signal.h> Gestione segnali Contiene la dichiarazione di funzioni per la gestione di condizioni di eccezione che si verificano durante l esecuzione, come l arrivo di un segnale di interrupt da una sorgente esterna, oppure un errore nell esecuzione. sig_atomic_t SIG_DFL SIG_ERR SIG_IGN SIGABRT SIGFPE SIGILL SIGINT SIGSEGV SIGTERM void (*signal(int sig, void (*func)(int)))(int); int raise(int sig); <stdalign.h> Specifiche di allineamento Contiene le macro alignas espansa in _Alignas e alignof espansa in _Alignof. Le altre macro sono utilizzabili con la direttiva del preprocessore #if: _Alignas_is_defined e _Alignof_is_defined, entrambe espanse nella costante intera 1. alignas alignas_is_defined <stdarg.h> Gestione lista di argomenti variabili in numero e tipo Contiene la dichiarazione di funzioni e/o macro che permettono di scandire tali liste, quindi può essere utile a sua volta per la realizzazione di funzioni che accettano un numero variabile di parametri. Gli oggetti di tipo va_list contengono le informazioni necessarie a lavorare con un numero variabile di argomenti. va_start

20 A02w20 / Appendice B inizializza l oggetto di tipo va_list in modo che possa essere utilizzato da va_arg e va_end. va_arg è una macro che viene espansa in un espressione che ha il valore e il tipo dell argomento successivo di un elenco variabile di argomenti e deve essere chiamata un numero di volte uguale al numero degli argomenti; modifica l oggetto dichiarato da va_list, in modo che punti al prossimo argomento dell elenco. va_end è una macro chiamata quando tutti gli elementi di un elenco variabile di argomenti, che era stato inizializzato dalla macro va_start sono stati elaborati; fa in modo che la restituzione del controllo della funzione sia corretto. va_list name va_start(name, lastarg) va_arg(name, type) va_end(name) Si veda il Capitolo 19. Dichiarazione del puntatore agli argomenti. Inizializzazione del puntatore all argomento, lastarg è l ultimo parametro nominato della funzione. Accede al prossimo argomento senza nome e aggiorna il puntatore. Esegue le azioni appropriate per la corretta terminazione di una funzione che ha utilizzato va_list. <stdatomic.h> Gestione di operazioni atomiche su dati condivisi tra i threads Definisce macro e dichiara tipi di dati e funzioni utili all esecuzione di operazioni atomiche su dati condivisi tra i thread. I thread sono parti di un processo (un programma in esecuzione) che condividono risorse e possono eseguire operazioni in parallelo. Un operazione è detta atomica quando deve avere accesso alla risorsa senza interruzioni, dall inizio dell esecuzione al suo completamento. Se una certa operazione deve essere atomica su un certo dato, mentre un thread la sta eseguendo nessun altro thread può accedere a quel dato. Le implementazioni che definiscono la macro STDC_NO_ATOMICS non forniscono questo header e non supportano le sue funzionalità. Segue l elenco delle macro e delle funzioni. ATOMIC_BOOL_LOCK_FREE ATOMIC_CHAR_LOCK_FREE ATOMIC_CHAR16_T_LOCK_FREE ATOMIC_CHAR32_T_LOCK_FREE ATOMIC_WCHAR_T_LOCK_FREE ATOMIC_SHORT_LOCK_FREE ATOMIC_INT_LOCK_FREE ATOMIC_LONG_LOCK_FREE ATOMIC_LLONG_LOCK_FREE ATOMIC_POINTER_LOCK_FREE ATOMIC_FLAG_INIT memory_order atomic_flag memory_order_relaxed memory_order_consume atomic_uint atomic_long atomic_ulong atomic_llong atomic_ullong atomic_char16_t atomic_char32_t atomic_wchar_t atomic_int_least8_t atomic_uint_least8_t atomic_int_least16_t atomic_uint_least16_t atomic_int_least32_t atomic_uint_least32_t atomic_int_least64_t

21 Libreria standard / A02w21 memory_order_acquire memory_order_release memory_order_acq_rel memory_order_seq_cst atomic_bool atomic_char atomic_schar atomic_uchar atomic_short atomic_ushort atomic_int atomic_size_t atomic_ptrdiff_t atomic_uint_least64_t atomic_int_fast8_t atomic_uint_fast8_t atomic_int_fast16_t atomic_uint_fast16_t atomic_int_fast32_t atomic_uint_fast32_t atomic_int_fast64_t atomic_uint_fast64_t atomic_intptr_t atomic_uintptr_t atomic_intmax_t atomic_uintmax_t #define ATOMIC_VAR_INIT(C value) void atomic_init(volatile A *obj, C value); type kill_dependency(type y); void atomic_thread_fence(memory_order order); void atomic_signal_fence(memory_order order); _Bool atomic_is_lock_free(const volatile A *obj); void atomic_store(volatile A *object, C desired); void atomic_store_explicit(volatile A *object, C desired, memory_order order); C atomic_load(volatile A *object); C atomic_load_explicit(volatile A *object, memory_order order); C atomic_exchange(volatile A *object, C desired); C atomic_exchange_explicit(volatile A *object, C desired, memory_order order); _Bool atomic_compare_exchange_strong(volatile A *object, C *expected, C desired); _Bool atomic_compare_exchange_strong_explicit( volatile A *object, C *expected, C desired, memory_order success, memory_order failure); _Bool atomic_compare_exchange_weak(volatile A *object, C *expected, C desired); _Bool atomic_compare_exchange_weak_explicit( volatile A *object, C *expected, C desired, memory_order success, memory_order failure); C atomic_fetch_key(volatile A *object, M operand); C atomic_fetch_key_explicit(volatile A *object, M operand, memory_order order); _Bool atomic_flag_test_and_set( volatile atomic_flag *object); _Bool atomic_flag_test_and_set_explicit( volatile atomic_flag *object, memory_order order); void atomic_flag_clear(volatile atomic_flag *object);

22 A02w22 / Appendice B void atomic_flag_clear_explicit( volatile atomic_flag *object, memory_order order); <stdbool.h> Tipi e valori booleani Definisce la macro bool espansa in _Bool. Le altre macro sono utilizzabili con le direttive #if del preprocessore: true che è espansa nella costante 1, false che è espansa nella costante 0 e bool_true_false_are_defined che è espansa nella costante 1. bool true false bool_true_false_are_defined <stddef.h> Definizioni standard Contiene le definizioni di: NULL, la costante di puntatore nullo; ptrdiff_t, in grado di contenere la differenza con segno tra due puntatori; size_t, il tipo (intero privo di segno) prodotto dalla funzione sizeof. ptrdiff_t size_t max_align_t wchar_t NULL offsetof(type, member-designator) STDC_WANT_LIB_EXT1 rsize_t Si vedano soprattutto i Capitoli 14 e 21. <stdint.h> Interi Dichiara insiemi di tipi interi che hanno grandezze specificate e definisce i corrispondenti insiemi di macro. Definisce anche macro che specificano i limiti di tipi interi corrispondenti ai tipi definiti in altri header standard. Segue l elenco delle macro e delle funzioni. intn_t INT_LEASTN_MIN PTRDIFF_MAX uintn_t INT_LEASTN_MAX SIG_ATOMIC_MIN int_leastn_t UINT_LEASTN_MAX SIG_ATOMIC_MAX uint_leastn_t INT_FASTN_MIN SIZE_MAX int_fastn_t INT_FASTN_MAX WCHAR_MIN uint_fastn_t UINT_FASTN_MAX WCHAR_MAX intptr_t INTPTR_MIN WINT_MIN uintptr_t INTPTR_MAX WINT_MAX intmax_t UINTPTR_MAX INTN_C(value) uintmax_t INTMAX_MIN UINTN_C(value) INTN_MIN INTMAX_MAX INTMAX_C(value) INTN_MAX UINTMAX_MAX UINTMAX_C(value)

23 Libreria standard / A02w23 UINTN_MAX PTRDIFF_MIN STDC_WANT_LIB_EXT1 RSIZE_MAX <stdio.h> Input e Output Comprende funzioni quali: int printf(const char *format,...) Converte, ordina in un formato e scrive sullo standard output un numero variabile di argomenti, indicati nel prototyping da... sotto il controllo della stringa format. int scanf(const char *format,...) Legge un insieme di caratteri da standard input, li interpreta secondo il formato specificato dalla stringa format e li memorizza negli argomenti i cui puntatori sono indicati nel prototyping da... Comprende altre funzioni di input e output quali: fprintf, fscanf, sprintf, sscanf, vprintf, vscanf, vfprintf, vfscanf, vsprintf, vsscanf, getc, putc, fgetc, fputc, getchar, putchar, fgets, fputs... Standard Segue l elenco I/O delle macro e delle funzioni. Stdin Stream dello standard input. Stdout Stream dello standard output. Stderr Stream dello standard error. EOF End Of File. getchar() Accetta in input un carattere. putchar(chr) Manda in output un carattere. print("format", Manda in output dati formattati. arg1,...) sprint(s, "format", Manda in output sulla stringa s. arg1,...) scanf("format", Legge dati formattati. &name1,...) sscanf("format", Legge dalla stringa s. &name1,...) gets_s(s, max) gets_s legge una linea di lunghezza minore di max caratteri e la assegna alla stringa s. La funzione gets_s sostituisce gets che con C11 è diventata obsoleta. Già C99 nella revisione del 2007 l aveva indicata come deprecabile per ragioni di sicurezza, infatti gets non fornisce alcuna protezione verso l eventuale overflowing della stringa in cui il dato è salvato: non prevede il paramatro max. Al contrario gets_s considera come violazione dei vincoli di runtime una linea di input che superi la lunghezza max del buffer e in quel caso restituisce un puntatore nullo. Se il compilatore non mette a disposizione la nuova funzione gets_s, un opzione può essere la funzione fgets indicando lo standard input: fgets(s, max, stdin). puts(s) Manda in output la stringa s.

24 A02w24 / Appendice B File I/O FILE *fp Dichiara il file pointer. Fopen("name", "mode") Punta al nome del file mode: r (read), w (write), a (append). getc(fp) Accetta in input un carattere. putc(chr, fp) Scrive un carattere. print("format", Manda in output dati formattati. arg1,...) fprint(fp, "format", Scrive sul file. arg1,...) fscanf("format", Legge dal file. &name1,...) fclose(fp) Chiude il file. ferror(fp) Restituisce un valore diverso da zero in caso di errore. feof(fp) Restituisce un valore diverso da zero se si è raggiunta la fine del file. fgets(s, max, fb) Legge una linea dal file (di lunghezza minore di max caratteri) e la assegna a s. fputs(s, fp) Scrive una linea di s sul file. size_t FILE fpos_t NULL _IOFBF _IOLBF _IONBF BUFSIZ EOF FOPEN_MAX FILENAME_MAX L_tmpnam SEEK_CUR SEEK_END SEEK_SET TMP_MAX stderr stdin stdout int remove(const char *filename); int rename(const char *old, const char *new); FILE *tmpfile(void); char *tmpnam(char *s); int fclose(file *stream); int fflush(file *stream); FILE *fopen(const char * restrict filename, const char * restrict mode); FILE *freopen(const char * restrict filename, const char * restrict mode, FILE * restrict stream); void setbuf(file * restrict stream, char * restrict buf); int setvbuf(file * restrict stream, char * restrict buf, int mode, size_t size); int fprintf(file * restrict stream, const char * restrict format,...); int fscanf(file * restrict stream, const char * restrict format,...); int printf(const char * restrict format,...); int scanf(const char * restrict format,...); int snprintf(char * restrict s, size_t n, const char * restrict format,...); int sprintf(char * restrict s, const char * restrict format,...);

25 Libreria standard / A02w25 int sscanf(const char * restrict s, const char * restrict format,...); int vfprintf(file * restrict stream, const char * restrict format, va_list arg); int vfscanf(file * restrict stream, const char * restrict format, va_list arg); int vprintf(const char * restrict format, va_list arg); int vscanf(const char * restrict format, va_list arg); int vsnprintf(char * restrict s, size_t n, const char * restrict format, va_list arg); int vsprintf(char * restrict s, const char * restrict format, va_list arg); int vsscanf(const char * restrict s, const char * restrict format, va_list arg); int fgetc(file *stream); char *fgets(char * restrict s, int n, FILE * restrict stream); int fputc(int c, FILE *stream); int fputs(const char * restrict s, FILE * restrict stream); int getc(file *stream); int getchar(void); int putc(int c, FILE *stream); int putchar(int c); int puts(const char *s); int ungetc(int c, FILE *stream); size_t fread(void * restrict ptr, size_t size, size_t nmemb, FILE * restrict stream); size_t fwrite(const void * restrict ptr, size_t size, size_t nmemb, FILE * restrict stream); int fgetpos(file * restrict stream, fpos_t * restrict pos); int fseek(file *stream, long int offset, int whence); int fsetpos(file *stream, const fpos_t *pos); long int ftell(file *stream); void rewind(file *stream); void clearerr(file *stream); int feof(file *stream); int ferror(file *stream); void perror(const char *s); STDC_WANT_LIB_EXT1 L_tmpnam_s TMP_MAX_S errno_t rsize_t errno_t tmpfile_s(file * restrict * restrict streamptr); errno_t tmpnam_s(char *s, rsize_t maxsize); errno_t fopen_s(file * restrict * restrict streamptr, const char * restrict filename, const char * restrict mode);

26 A02w26 / Appendice B errno_t freopen_s(file * restrict * restrict newstreamptr, const char * restrict filename, const char * restrict mode, FILE * restrict stream); int fprintf_s(file * restrict stream, const char * restrict format,...); int fscanf_s(file * restrict stream, const char * restrict format,...); int printf_s(const char * restrict format,...); int scanf_s(const char * restrict format,...); int snprintf_s(char * restrict s, rsize_t n, const char * restrict format,...); int sprintf_s(char * restrict s, rsize_t n, const char * restrict format,...); int sscanf_s(const char * restrict s, const char * restrict format,...); int vfprintf_s(file * restrict stream, const char * restrict format, va_list arg); int vfscanf_s(file * restrict stream, const char * restrict format, va_list arg); int vprintf_s(const char * restrict format, va_list arg); int vscanf_s(const char * restrict format, va_list arg); int vsnprintf_s(char * restrict s, rsize_t n, const char * restrict format, va_list arg); int vsprintf_s(char * restrict s, rsize_t n, const char * restrict format, va_list arg); int vsscanf_s(const char * restrict s, const char * restrict format, va_list arg); char *gets_s(char *s, rsize_t n); Le funzioni stdio sono descritte e utilizzate in tutto il testo; si vedano soprattutto i Capitoli 5, 6, 17 e 19. <stdlib.h> Utilità generale Vi sono dichiarate funzioni come int rand(void), che restituisce un valore intero tra 0 e RAND_MAX (una costante definita in stdlib e dipendente dall implementazione) e void srand(unsigned int seed), che usa il proprio argomento come seme per la generazione di una nuova sequenza di numeri pseudo-casuali ottenibile con chiamate successive di rand. Se srand non viene invocata o viene invocata con lo stesso seme, successive chiamate di rand possono generare sequenze identiche. int abs(int n) Valore assolto di int n. long int labs (long int n) Valore assolto di long n. div_t div(int n, int d) Quoziente e resto degli int n, d ritorna una ldiv_t ldiv(long int n, long int d) struttura con div_t.quot e div_t.rem. Quoziente e resto dei long n, d ritorna una struttura con ldiv_t.quot e ldiv_t.rem.

27 Libreria standard / A02w27 int rand(void) Intero pseudo randomico maggiore di zero e minore uguale di RABD_MAX [0, RABD_MAX]. void srand(unsigned int n) Setta il seme randomico a n. exit(status) Termina l esecuzione del programma. int system(const char *s) Passa la stringa s al sistema per l esecuzione. Funzioni per la conversione dei numeri quali int atoi(const char *s), che converte una stringa in un intero; atol e atof, che convertono rispettivamente una stringa in long e double. Funzioni di conversione più sofisticate, quali: double strtod(const char *string, char **endptr) long int strtol(const char *string, char **endptr, int base) unsigned long int strtoul(const char *string, char **endptr, int base) che oltre a restituire il valore convertito, rispettivamente double, long e unsigned long, ritornano un puntatore all elemento dell array in cui la funzione ha interrotto l acquisizione dati (non necessariamente l ultimo della stringa, per esempio in caso di un carattere che non ha senso in una conversione a numero) utile per controllarne il contenuto e capire l errore. Nel caso di conversione a intero, il valore restituito è espresso nella base indicata da base. Inoltre queste ultime funzioni interpretano la stringa secondo le convenzioni del C, per esempio 12, 0xC e 014 vengono convertite nello stesso numero. Conversioni double atof(const char *s) int atoi(const char *s) long int atol(const char *s) double strtod(const char * restrict s, char ** restrict endp) long int strtol(const char * restrict s,char ** restrict endp, int base) Converte la stringa s (la stringa puntata da s) a un double. Converte la stringa s a un integer. Converte la stringa s a un long. Converte la porzione la stringa s i un double. Non considera gli spazi bianchi iniziali della stringa (i caratteri specificati dalla funzione isspace). Si ferma appena incontra un carattere non riconducibile a una rappresentazione numerica. La funzione fornisce in endp il puntatore alla parte finale della stringa, composta eventualmente da caratteri non riconosciuti, tra cui il carattere di fine stringa. Converte la porzione iniziale della stringa s in un long. Non considera gli spazi bianchi iniziali della stringa (i caratteri specificati dalla funzione isspace). Si ferma appena incontra un carattere non riconducibile a una rappresentazione numerica. La conversione considera che il numero nella stringa sia rappresentato nella base base. La funzione fornisce in endp il puntatore alla parte finale della stringa, composta dai caratteri non convertiti, tra cui il carattere di fine stringa.

28 A02w28 / Appendice B Conversioni unsigned long int strtoul(const char * restrict s, char ** restrict endp, int base) Converte la porzione iniziale della stringa s in un unsigned long. Non considera gli spazi bianchi iniziali della stringa (i caratteri specificati dalla funzione isspace). Si ferma appena incontra un carattere non riconducibile a una rappresentazione numerica. La conversione considera che il numero nella stringa sia rappresentato nella base base. La funzione fornisce in endp il puntatore alla parte finale della stringa, composta dai caratteri non convertiti, tra cui il carattere di fine stringa. Vi è il prototype delle funzioni per la gestione della memoria: void *malloc(size_t dimensione), dove size_t è il tipo intero senza segno restituito da sizeof, che ritorna un puntatore alla memoria allocata la cui ampiezza è specificata da dimensione; le funzioni di allocazione di memoria come malloc che ritornano un puntatore a void, cioè a tipo generico, e perciò devono essere esplicitamente convertiti in un tipo specifico. Per esempio, pi=(int *) malloc (sizeof(int)), che alloca uno spazio di memoria sufficiente a contenere un int, attraverso la conversione esplicita di tipo o cast restituisce un puntatore a intero. Vi è dichiarata la funzione void *calloc(size_t numele, size_t dimensione), che alloca uno spazio di memoria di ampiezza numele*dimensione; la funzione void *realloc(void *ptr, size_t dimensione), che modifica un area di memoria riservata precedentemente, dove dimensione specifica la nuova ampiezza dell area; void free(void *ptr), che rilascia la memoria puntata da ptr. In realloc e free il puntatore ptr deve contenere un indirizzo restituito da una precedente chiamata di malloc, calloc o realloc. Allocazione di memoria void *malloc(size_t dimensione) void *calloc(size_t numele, size_t dimensione) void *realloc(void *ptr, size_t dimensione) void free(void *ptr) Alloca memoria. Alloca memoria. Cambia la dimenzione dell oggetto. Libera la memoria. Funzioni sugli array void *bsearch(const void *key, const void *array, size_t n, size_t dimensione, int (*compar)(const void *, const void *)) Ricerca il valore key nell array di n elementi. La dimensione di ogni elemento è specificata da dimensione. Alla funzione compar sono passati due argomenti: il puntatore a key e un puntatore a un elemento dell array, la funzone ritorna un valore minore, uguale o più grande di zero se il valore di key è considerato rispettivamente minore, uguale o più grande del valore dell elemento dell array.

29 Libreria standard / A02w29 Funzioni sugli array void qsort(void *array, size_t n, size_t dimensione, int (*compar)(const void *, const void *)) Ordina l array di n elementi n modo ascendente. La dimensione di ogni elemento è specificata da dimensione. Alla funzione compar sono passati due elementi del vettore, la funzone ritorna un valore minore, uguale o più grande di zero se il valore del primo elemento è considerato rispettivamente minore, uguale o più grande del valore del secondo elemento. Segue l elenco delle macro e delle funzioni. size_t wchar_t div_t ldiv_t lldiv_t NULL EXIT_FAILURE EXIT_SUCCESS RAND_MAX MB_CUR_MAX double atof(const char *nptr); int atoi(const char *nptr); long int atol(const char *nptr); long long int atoll(const char *nptr); double strtod(const char * restrict nptr, char ** restrict endptr); float strtof(const char * restrict nptr, char ** restrict endptr); long double strtold(const char * restrict nptr, char ** restrict endptr); long int strtol(const char * restrict nptr, char ** restrict endptr, int base); long long int strtoll(const char * restrict nptr, char ** restrict endptr, int base); unsigned long int strtoul(const char * restrict nptr, char ** restrict endptr, int base); unsigned long long int strtoull(const char * restrict nptr, char ** restrict endptr, int base); int rand(void); void srand(unsigned int seed); void *aligned_alloc(size_t alignment, size_t size); void *calloc(size_t nmemb, size_t size); void free(void *ptr); void *malloc(size_t size); void *realloc(void *ptr, size_t size); _Noreturn void abort(void); int atexit(void (*func)(void)); int at_quick_exit(void (*func)(void)); _Noreturn void exit(int status); _Noreturn void _Exit(int status);

30 A02w30 / Appendice B char *getenv(const char *name); _Noreturn void quick_exit(int status); int system(const char *string); void *bsearch(const void *key, const void *base, size_t nmemb, size_t size, int (*compar)(const void *, const void *)); void qsort(void *base, size_t nmemb, size_t size, int (*compar)(const void *, const void *)); int abs(int j); long int labs(long int j); long long int llabs(long long int j); div_t div(int numer, int denom); ldiv_t ldiv(long int numer, long int denom); lldiv_t lldiv(long long int numer, long long int denom); int mblen(const char *s, size_t n); int mbtowc(wchar_t * restrict pwc, const char * restrict s, size_t n); int wctomb(char *s, wchar_t wchar); size_t mbstowcs(wchar_t * restrict pwcs, const char * restrict s, size_t n); size_t wcstombs(char * restrict s, const wchar_t * restrict pwcs, size_t n); STDC_WANT_LIB_EXT1 errno_t rsize_t constraint_handler_t constraint_handler_t set_constraint_handler_s( constraint_handler_t handler); void abort_handler_s(const char * restrict msg, void * restrict ptr, errno_t error); void ignore_handler_s(const char * restrict msg, void * restrict ptr, errno_t error); errno_t getenv_s(size_t * restrict len, char * restrict value, rsize_t maxsize, const char * restrict name); void *bsearch_s(const void *key, const void *base, rsize_t nmemb, rsize_t size, int (*compar)(const void *k, const void *y, void *context), void *context); errno_t qsort_s(void *base, rsize_t nmemb, rsize_t size, int (*compar)(const void *x, const void *y, void *context), void *context); errno_t wctomb_s(int * restrict status, char * restrict s, rsize_t smax,wchar_t wc);

31 Libreria standard / A02w31 errno_t mbstowcs_s(size_t * restrict retval, wchar_t * restrict dst, rsize_t dstmax, const char * restrict src, rsize_t len); errno_t wcstombs_s(size_t * restrict retval, char * restrict dst, rsize_t dstmax, const wchar_t * restrict src, rsize_t len); Si vedano i Capitoli 13, 14, 19 e 20. <stdnoreturn.h> No return Definisce la macro noreturn che si espande in _Noreturn. <string.h> Gestione di stringhe size_t strlen(const char *cs) char *strcpy(char * restrict s, const char * restrict cs) char *strncpy(char * restrict s, const char * restrict cs, size_t n) char *strcat(char * restrict s, const char * restrict cs) char *strncat(char * restrict s, const char * restrict cs, size_t n) int strcmp(const char *cs, const char *cs2) int strncmp(const char *cs, const char *cs2, size_t n) char *strchr(const char *cs, int c) char *strrchr(const char *cs, int c) void *memcpy(void * restrict s, const void * restrict cs, size_t n) void *memmove(void *s, const void *cs, size_t n) void *memcmp(const void *cs, const void *cs2, size_t n) void *memchr(const void *cs, int c, size_t n) void *memset(void *s, int c, size_t n) Restituisce la lunghezza il numero di caratteri di cs. Copia cs su s. Copia un massimo di n caratteri di cs su s. Concatena cs dopo s. Concatena un massimo di n caratteri di cs dopo s. Confronta cs2 con cs. Confronta solo i primi n caratteri di cs2 con cs. Restituisce il puntatore alla prima occorrenza di c in cs. Restituisce il puntatore all ultima occorrenza di c in s. Copia n caratteri da cs a s. Copia n caratteri da cs in s. Funziona anche in caso di sovrascrittura (s uguale a cs). Confronta i primi n caratteri di cs2 con cs. Restituisce il puntatore alla prima occorrenza di c nei primi n caratteri di s. Assegna c ai primi nei primi n caratteri di s.

32 A02w32 / Appendice B Segue l elenco delle macro e delle funzioni. size_t NULL void *memcpy(void * restrict s1, const void * restrict s2, size_t n); void *memmove(void *s1, const void *s2, size_t n); char *strcpy(char * restrict s1, const char * restrict s2); char *strncpy(char * restrict s1, const char * restrict s2, size_t n); char *strcat(char * restrict s1, const char * restrict s2); char *strncat(char * restrict s1, const char * restrict s2, size_t n); int memcmp(const void *s1, const void *s2, size_t n); int strcmp(const char *s1, const char *s2); int strcoll(const char *s1, const char *s2); int strncmp(const char *s1, const char *s2, size_t n); size_t strxfrm(char * restrict s1, const char * restrict s2, size_t n); void *memchr(const void *s, int c, size_t n); char *strchr(const char *s, int c); size_t strcspn(const char *s1, const char *s2); char *strpbrk(const char *s1, const char *s2); char *strrchr(const char *s, int c); size_t strspn(const char *s1, const char *s2); char *strstr(const char *s1, const char *s2); char *strtok(char * restrict s1, const char * restrict s2); void *memset(void *s, int c, size_t n); char *strerror(int errnum); size_t strlen(const char *s); STDC_WANT_LIB_EXT1 errno_t rsize_t errno_t memcpy_s(void * restrict s1, rsize_t s1max, const void * restrict s2, rsize_t n); errno_t memmove_s(void *s1, rsize_t s1max, const void *s2, rsize_t n); errno_t strcpy_s(char * restrict s1, rsize_t s1max, const char * restrict s2); errno_t strncpy_s(char * restrict s1, rsize_t s1max, const char * restrict s2, rsize_t n); errno_t strcat_s(char * restrict s1, rsize_t s1max, const char * restrict s2); errno_t strncat_s(char * restrict s1, rsize_t s1max, const char * restrict s2, rsize_t n); char *strtok_s(char * restrict s1, rsize_t * restrict s1max, const char * restrict s2, char ** restrict ptr);

33 Libreria standard / A02w33 errno_t memset_s(void *s, rsize_t smax, int c, rsize_t n) errno_t strerror_s(char *s, rsize_t maxsize, errno_t errnum); size_t strerrorlen_s(errno_t errnum); size_t strnlen_s(const char *s, size_t maxsize); Si vedano soprattutto i Capitoli 13, 14, 18. <tgmath.h> Matematica dei tipi-generici Include gli headers <math.h> e <complex.h> e definisce molte macro per i tipi-generici. acos sqrt fmod nextafter asin fabs frexp nexttoward atan atan2 hypot remainder acosh cbrt ilogb remquo asinh ceil ldexp rint atanh copysign lgamma round cos erf llrint scalbn sin erfc llround scalbln tan exp2 log10 tgamma cosh expm1 log1p trunc sinh fdim log2 carg tanh floor logb cimag exp fma lrint conj log fmax lround cproj pow fmin nearbyint creal <threads.h> Gestione multithreads Include l header time.h. Definisce macro e dichiara tipi di dati, costanti e funzioni utili al supporto di thread multipli, quali quelle necessarie alla creazione e la gestione dei thread e alle risorse di memoria. Le implementazioni che definiscono la macro STDC_NO_THREADS non forniscono questo header e non supportano le sue funzionalità. Segue l elenco delle macro e delle funzioni. thread_local ONCE_FLAG_INIT TSS_DTOR_ITERATIONS cnd_t thrd_t tss_t mtx_t tss_dtor_t thrd_start_t once_flag mtx_plain mtx_recursive mtx_timed thrd_timedout thrd_success thrd_busy thrd_error thrd_nomem void call_once(once_flag *flag, void (*func)(void)); int cnd_broadcast(cnd_t *cond); void cnd_destroy(cnd_t *cond);

34 A02w34 / Appendice B int cnd_init(cnd_t *cond); int cnd_signal(cnd_t *cond); int cnd_timedwait(cnd_t *restrict cond, mtx_t *restrict mtx, const struct timespec *restrict ts); int cnd_wait(cnd_t *cond, mtx_t *mtx); void mtx_destroy(mtx_t *mtx); int mtx_init(mtx_t *mtx, int type); int mtx_lock(mtx_t *mtx); int mtx_timedlock(mtx_t *restrict mtx, const struct timespec *restrict ts); int mtx_trylock(mtx_t *mtx); int mtx_unlock(mtx_t *mtx); int thrd_create(thrd_t *thr, thrd_start_t func, void *arg); thrd_t thrd_current(void); int thrd_detach(thrd_t thr); int thrd_equal(thrd_t thr0, thrd_t thr1); _Noreturn void thrd_exit(int res); int thrd_join(thrd_t thr, int *res); int thrd_sleep(const struct timespec *duration, struct timespec *remaining); void thrd_yield(void); int tss_create(tss_t *key, tss_dtor_t dtor); void tss_delete(tss_t key); void *tss_get(tss_t key); int tss_set(tss_t key, void *val); <time.h> Gestione della data e dell ora Le funzioni disponibili sono di tre tipologie: tempi assoluti, che rappresentano data e ora nel calendario gregoriano; tempi locali, nel fuso orario specifico; variazioni dei tempi locali, che specificano una modifica temporanea dei tempi locali, per esempio per l introduzione dell ora legale. Vi sono dichiarate la funzione time, che ritorna l ora corrente, e la funzione clock che restituisce la quantità di tempo di CPU impiegata dal programma. clock_t clock(void) CLOCKS_PER_SEC clock_t time_t time(time_t *timer) La funzione clock restituisce il tempo di esecuzione. Per determinare il numero di secondi, il valore restituito dovrebbe essere diviso per CLOCKS_PER_SEC. Per esempio: inizio=clock();...;fine=clock(); tempo=(inizio-fine)/clocks_per_sec; La macro è espansa in una costante di tipo clock_t che corrisponde al numero di clock per secondo del computer. Tipo aritmetico che conta le unità di tempo trascorse. La funzione ritorna la data e l ora attuale del calendario. Se è restituito il valore 1 significa che il calendario non è disponibile. Se timer non è un puntatore nullo, il valore di ritorno della funzione viene assegnato anche a l oggetto puntato da timer.

35 Libreria standard / A02w35 double difftime (time_t time2, time_t time1) time_t time2-time1 in secondi (tipo double). La funzione ritorna la differenza fra due tempi (nel senso di date e ore) del calendario. Tipo aritmetico che rappresenta la quantità di tempo trascorsa a partire da un epoca di riferimento. Struttura tm struct tm { tm_sec Secondi dopo i minuti [0, 60] tm_min Minuti dopo le ore [0, 59] tm_hour Ora dopo la mezzanotte [0, 23] tm_mday Giorno del mese [1, 31] tm_mon Mese da gennaio [0, 11] tm_year Anno dal 1900 ttm_wday Giorni della settimana dalla domenica [0, 6] tm_yday Giorni dal primo gennaio [1, 365] tm_isdst tp time_t mktime(struct tm *tp) char *asctime (const struct tm *tp) char ctime (const time_t *timer) struct tm *gmtime (const time_t *timer) struct tm *localtime (const time_t *timer) Ora estiva. Contiene un valore positivo se è in vigore l ora legale; zero se l ora è quella solare; un valore negativo se l informazione non è disponibile. tp è un puntatore a una struttura di tipo tm. Converte l ora e la data locale a quella del calendario. Convete il tempo espresso in tp a stringa. Converte l ora e la data del calendario espresso in quella locale. Converte l ora e la data del calendario in GMT. Converte l ora e la data del calendario in quella locale. Segue l elenco delle macro e delle funzioni. NULL CLOCKS_PER_SEC TIME_UTC size_t clock_t time_t struct timespec struct tm clock_t clock(void); double difftime(time_t time1, time_t time0); time_t mktime(struct tm *timeptr); time_t time(time_t *timer); int timespec_get(timespec *ts, int base); char *asctime(const struct tm *timeptr); char *ctime(const time_t *timer); struct tm *gmtime(const time_t *timer); struct tm *localtime(const time_t *timer); size_t strftime(char * restrict s, size_t maxsize, const char * restrict format, const struct tm * restrict timeptr); STDC_WANT_LIB_EXT1

36 A02w36 / Appendice B errno_t rsize_t errno_t asctime_s(char *s, rsize_t maxsize, const struct tm *timeptr); errno_t ctime_s(char *s, rsize_t maxsize, const time_t *timer); struct tm *gmtime_s(const time_t * restrict timer, struct tm * restrict result); struct tm *localtime_s(const time_t * restrict timer, struct tm * restrict result); <uchar.h> Unicode Dichiara tipi e funzioni che manipolano caratteri Unicode. char16_t è un tipo intero unsigned usato per memorizzare caratteri a 16-bit, UTF16. char32_t è un tipo intero unsigned usato per memorizzare caratteri a 32-bit, UTF32. Comprende le funzioni di conversione fra un tipo all altro, i prefissi u e U per le stringhe letterali e il prefisso u8 per UTF-8. mbstate_t size_t char16_t char32_t size_t mbrtoc16(char16_t * restrict pc16, const char * restrict s, size_t n, mbstate_t * restrict ps); size_t c16rtomb(char * restrict s, char16_t c16, mbstate_t * restrict ps); size_t mbrtoc32(char32_t * restrict pc32, const char * restrict s, size_t n, mbstate_t * restrict ps); size_t c32rtomb(char * restrict s, char32_t c32, mbstate_t * restrict ps); <wchar.h> Utility per caratteri estesi e multibyte Definisce macro e dichiara tipi e funzioni che aiutano a gestire caratteri estesi e multibyte. wchar_t size_t mbstate_t wint_t struct tm NULL WCHAR_MAX WCHAR_MIN WEOF int fwprintf(file * restrict stream, const wchar_t * restrict format,...); int fwscanf(file * restrict stream, const wchar_t * restrict format,...); int swprintf(wchar_t * restrict s, size_t n, const wchar_t * restrict format,...); int swscanf(const wchar_t * restrict s, const wchar_t * restrict format,...); int vfwprintf(file * restrict stream, const wchar_t * restrict format, va_list arg); int vfwscanf(file * restrict stream, const wchar_t * restrict format, va_list arg);

37 Libreria standard / A02w37 int vswprintf(wchar_t * restrict s, size_t n, const wchar_t * restrict format, va_list arg); int vswscanf(const wchar_t * restrict s, const wchar_t * restrict format, va_list arg); int vwprintf(const wchar_t * restrict format, va_list arg); int vwscanf(const wchar_t * restrict format, va_list arg); int wprintf(const wchar_t * restrict format,...); int wscanf(const wchar_t * restrict format,...); wint_t fgetwc(file *stream); wchar_t *fgetws(wchar_t * restrict s, int n, FILE * restrict stream); wint_t fputwc(wchar_t c, FILE *stream); int fputws(const wchar_t * restrict s, FILE * restrict stream); int fwide(file *stream, int mode); wint_t getwc(file *stream); wint_t getwchar(void); wint_t putwc(wchar_t c, FILE *stream); wint_t putwchar(wchar_t c); wint_t ungetwc(wint_t c, FILE *stream); double wcstod(const wchar_t * restrict nptr, wchar_t ** restrict endptr); float wcstof(const wchar_t * restrict nptr, wchar_t ** restrict endptr); long double wcstold(const wchar_t * restrict nptr, wchar_t ** restrict endptr); long int wcstol(const wchar_t * restrict nptr, wchar_t ** restrict endptr, int base); long long int wcstoll(const wchar_t * restrict nptr, wchar_t ** restrict endptr, int base); unsigned long int wcstoul(const wchar_t * restrict nptr, wchar_t ** restrict endptr, int base); unsigned long long int wcstoull(const wchar_t * restrict nptr, wchar_t ** restrict endptr, int base); wchar_t *wcscpy(wchar_t * restrict s1, const wchar_t * restrict s2); wchar_t *wcsncpy(wchar_t * restrict s1, const wchar_t * restrict s2, size_t n); wchar_t *wmemcpy(wchar_t * restrict s1, const wchar_t * restrict s2, size_t n); wchar_t *wmemmove(wchar_t *s1, const wchar_t *s2, size_t n); wchar_t *wcscat(wchar_t * restrict s1, const wchar_t * restrict s2); wchar_t *wcsncat(wchar_t * restrict s1, const wchar_t * restrict s2, size_t n); int wcscmp(const wchar_t *s1, const wchar_t *s2);

38 A02w38 / Appendice B int wcscoll(const wchar_t *s1, const wchar_t *s2); int wcsncmp(const wchar_t *s1, const wchar_t *s2,size_t n); size_t wcsxfrm(wchar_t * restrict s1, const wchar_t * restrict s2, size_t n); int wmemcmp(const wchar_t *s1, const wchar_t *s2,size_t n); wchar_t *wcschr(const wchar_t *s, wchar_t c); size_t wcscspn(const wchar_t *s1, const wchar_t *s2); wchar_t *wcspbrk(const wchar_t *s1, const wchar_t *s2); wchar_t *wcsrchr(const wchar_t *s, wchar_t c); size_t wcsspn(const wchar_t *s1, const wchar_t *s2); wchar_t *wcsstr(const wchar_t *s1, const wchar_t *s2); wchar_t *wcstok(wchar_t * restrict s1, const wchar_t * restrict s2, wchar_t ** restrict ptr); wchar_t *wmemchr(const wchar_t *s, wchar_t c, size_t n); size_t wcslen(const wchar_t *s); wchar_t *wmemset(wchar_t *s, wchar_t c, size_t n); size_t wcsftime(wchar_t * restrict s, size_t maxsize, const wchar_t * restrict format, const struct tm * restrict timeptr); wint_t btowc(int c); int wctob(wint_t c); int mbsinit(const mbstate_t *ps); size_t mbrlen(const char * restrict s, size_t n, mbstate_t * restrict ps); size_t mbrtowc(wchar_t * restrict pwc, const char * restrict s, size_t n, mbstate_t * restrict ps); size_t wcrtomb(char * restrict s, wchar_t wc, mbstate_t * restrict ps); size_t mbsrtowcs(wchar_t * restrict dst, const char ** restrict src, size_t len, mbstate_t * restrict ps); size_t wcsrtombs(char * restrict dst, const wchar_t ** restrict src, size_t len, mbstate_t * restrict ps); STDC_WANT_LIB_EXT1 errno_t rsize_t int fwprintf_s(file * restrict stream, const wchar_t * restrict format,...); int fwscanf_s(file * restrict stream, const wchar_t * restrict format,...); int snwprintf_s(wchar_t * restrict s, rsize_t n, const wchar_t * restrict format,...); int swprintf_s(wchar_t * restrict s, rsize_t n, const wchar_t * restrict format,...); int swscanf_s(const wchar_t * restrict s, const wchar_t * restrict format,...);

39 Libreria standard / A02w39 int vfwprintf_s(file * restrict stream, const wchar_t * restrict format, va_list arg); int vfwscanf_s(file * restrict stream, const wchar_t * restrict format, va_list arg); int vsnwprintf_s(wchar_t * restrict s,rsize_t n, const wchar_t * restrict format, va_list arg); int vswprintf_s(wchar_t * restrict s, rsize_t n, const wchar_t * restrict format, va_list arg); int vswscanf_s(const wchar_t * restrict s, const wchar_t * restrict format,va_list arg); int vwprintf_s(const wchar_t * restrict format,va_list arg); int vwscanf_s(const wchar_t * restrict format,va_list arg); int wprintf_s(const wchar_t * restrict format,...); int wscanf_s(const wchar_t * restrict format,...); errno_t wcscpy_s(wchar_t * restrict s1,rsize_t s1max, const wchar_t * restrict s2); errno_t wcsncpy_s(wchar_t * restrict s1,rsize_t s1max, const wchar_t * restrict s2,rsize_t n); errno_t wmemcpy_s(wchar_t * restrict s1,rsize_t s1max, const wchar_t * restrict s2,rsize_t n); errno_t wmemmove_s(wchar_t *s1, rsize_t s1max, const wchar_t *s2, rsize_t n); errno_t wcscat_s(wchar_t * restrict s1,rsize_t s1max, const wchar_t * restrict s2); errno_t wcsncat_s(wchar_t * restrict s1,rsize_t s1max, const wchar_t * restrict s2,rsize_t n); wchar_t *wcstok_s(wchar_t * restrict s1, rsize_t * restrict s1max, const wchar_t * restrict s2, wchar_t ** restrict ptr); size_t wcsnlen_s(const wchar_t *s, size_t maxsize); errno_t wcrtomb_s(size_t * restrict retval, char * restrict s, rsize_t smax, wchar_t wc, mbstate_t * restrict ps); errno_t mbsrtowcs_s(size_t * restrict retval, wchar_t * restrict dst, rsize_t dstmax, const char ** restrict src, rsize_t len, mbstate_t * restrict ps); errno_t wcsrtombs_s(size_t * restrict retval, char * restrict dst, rsize_t dstmax, const wchar_t ** restrict src, rsize_t len, mbstate_t * restrict ps); <wctype.h> Utility per la configurazione e la classificazione dei caratteri estesi Definisce una macro, tre tipi e molte funzioni per la configurazione e la classificazione dei caratteri estesi. wint_t wctrans_t wctype_t WEOF int iswalnum(wint_t wc); int iswalpha(wint_t wc);

40 A02w40 / Appendice B int iswblank(wint_t wc); int iswcntrl(wint_t wc); int iswdigit(wint_t wc); int iswgraph(wint_t wc); int iswlower(wint_t wc); int iswprint(wint_t wc); int iswpunct(wint_t wc); int iswspace(wint_t wc); int iswupper(wint_t wc); int iswxdigit(wint_t wc); int iswctype(wint_t wc, wctype_t desc); wctype_t wctype(const char *property); wint_t towlower(wint_t wc); wint_t towupper(wint_t wc); wint_t towctrans(wint_t wc, wctrans_t desc); wctrans_t wctrans(const char *property); Lo standard garantisce che inclusioni multiple di uno stesso file header non portano alcun effetto negativo e che l ordine di inclusione è ininfluente. Dunque un header può essere incluso in qualsiasi ordine e un qualsiasi numero di volte. Unica eccezione per <assert.h> in dipendenza dalla definizione di NDE- BUG, se usata l header deve essere incluso al di fuori da ogni dichiarazione e definizione esterna e prima di ogni dichiarazione di funzione e di definizione di macro o di tipo dato.