<cstdlib>

Include l'intestazione <stdlib.h> della libreria C Standard e aggiunge i nomi associati allo spazio dei std nomi. L'inclusione di questa intestazione garantisce che i nomi dichiarati usando il collegamento esterno nell'intestazione della libreria standard C siano dichiarati nello spazio dei std nomi .

Nota

<stdlib.h> non include il tipo wchar_t.

Requisiti

Intestazione: <cstdlib>

Spazio dei nomi: std

Spazio dei nomi e macro

namespace std {
    using size_t = see definition;
    using div_t = see definition;
    using ldiv_t = see definition;
    using lldiv_t = see definition;
}

#define NULL
#define EXIT_FAILURE
#define EXIT_SUCCESS
#define RAND_MAX
#define MB_CUR_MAX

Solo funzioni di esposizione

extern "C" using c-atexit-handler = void();
extern "C++" using atexit-handler = void();
extern "C" using c-compare-pred = int(const void*, const void*);
extern "C++" using compare-pred = int(const void*, const void*);

Funzioni di avvio e terminazione

Funzione	Descrizione
_Exit	Termina il programma senza usare distruttori o funzioni registrate.
abort	Termina il programma senza usare distruttori.
atexit	Registra la funzione per la terminazione del programma.
exit	Elimina definitivamente gli oggetti con archiviazione statica e thread, quindi restituisce il controllo .
at_quick_exit	Registra la funzione senza argomenti per la terminazione del programma.
quick_exit	Registra la funzione con oggetti conservati per la terminazione del programma.
getenv	Vedere Informazioni di riferimento sulla libreria standard C.
system	Vedere Informazioni di riferimento sulla libreria standard C.

_Exit

[[noreturn]] void _Exit(int status) noexcept;

Osservazioni:

Il programma viene terminato senza eseguire distruttori per oggetti di durata di archiviazione automatica, thread o statica e senza chiamare le funzioni passate a atexit(). La funzione _Exit è sicura per i segnali.

abort

[[noreturn]] void abort() noexcept;

Osservazioni:

Il programma viene terminato senza eseguire distruttori per oggetti di durata di archiviazione automatica, thread o statica e senza chiamare le funzioni passate a atexit(). La funzione abort è sicura per i segnali.

at_quick_exit

int at_quick_exit(c-atexit-handler * func) noexcept;
int at_quick_exit(atexit-handler * func) noexcept;

Valore restituito

Zero se la registrazione ha esito positivo, diversa da zero se ha esito negativo.

Osservazioni:

Le at_quick_exit() funzioni registrano una funzione func, chiamata senza argomenti quando quick_exit() viene chiamato . Una chiamata a at_quick_exit() che non viene eseguita prima che tutte le chiamate a quick_exit() non abbiano esito positivo. Le at_quick_exit() funzioni non introducono una gara di dati. L'ordine di registrazione può essere indeterminato se at_quick_exit() è stato chiamato da più thread. Poiché at_quick_exit() le registrazioni sono distinte dalle atexit() registrazioni, le applicazioni potrebbero dover chiamare entrambe le funzioni di registrazione usando lo stesso argomento. MSVC supporta la registrazione di almeno 32 funzioni.

atexit

int atexit(c-atexit-handler * func) noexcept;
int atexit(atexit-handler * func) noexcept;

Osservazioni:

Le atexit() funzioni registrano la funzione a func cui punta da per essere chiamata senza argomenti alla normale terminazione del programma. Una chiamata a atexit() che non viene eseguita prima che una chiamata a exit() non riesca. Le atexit() funzioni non introducono una gara di dati.

Valore restituito

Restituisce zero se la registrazione ha esito positivo, diversa da zero se ha esito negativo.

exit

[[noreturn]] void exit(int status);

Osservazioni:

In primo luogo, gli oggetti con durata di archiviazione thread e associati al thread corrente vengono eliminati definitivamente.

Successivamente, gli oggetti con durata di archiviazione statica vengono eliminati definitivamente e vengono chiamate le funzioni registrate chiamando atexit() . Gli oggetti automatici non vengono eliminati definitivamente quando exit() viene chiamato . Se il controllo lascia una funzione registrata chiamata da exit() perché la funzione non fornisce un gestore per un'eccezione generata, std::terminate() viene chiamata . Una funzione viene chiamata una volta per ogni volta che viene registrata. Gli oggetti con durata di archiviazione automatica vengono tutti eliminati definitivamente in un programma la cui main funzione non contiene oggetti automatici ed esegue la chiamata a exit(). Il controllo può essere trasferito direttamente a tale main funzione generando un'eccezione rilevata in main.

Successivamente, tutti i flussi C aperti (come mediato dalle firme di funzione dichiarate in <cstdio>) con dati memorizzati nel buffer non scritti vengono scaricati, tutti i flussi C aperti vengono chiusi e tutti i file creati dalla chiamata tmpfile() vengono rimossi.

Infine, il controllo viene restituito all'ambiente host. Quando status è zero o EXIT_SUCCESS, viene restituita una forma definita dall'implementazione della terminazione con esito positivo dello stato. MSVC restituisce un valore pari a zero. Se status è EXIT_FAILURE, MSVC restituisce un valore pari a 3. In caso contrario, MSVC restituisce il valore del status parametro.

getenv

char* getenv(const char* name);

quick_exit

[[noreturn]] void quick_exit(int status) noexcept;

Osservazioni:

In genere, le funzioni registrate dalle chiamate a at_quick_exit() vengono chiamate nell'ordine inverso della registrazione. Questo ordine non si applica alle funzioni registrate dopo che sono già state chiamate altre funzioni registrate. Non viene eliminato alcun oggetto quando quick_exit() viene chiamato . Se il controllo lascia una funzione registrata chiamata da quick_exit() perché la funzione non fornisce un gestore per un'eccezione generata, std::terminate() viene chiamata . Una funzione registrata tramite at_quick_exit() viene richiamata dal thread che chiama quick_exit(), che può essere un thread diverso da quello che lo ha registrato. Ciò significa che le funzioni registrate non devono basarsi sull'identità degli oggetti con durata di archiviazione dei thread. Dopo aver chiamato le funzioni registrate, quick_exit() chiama _Exit(status). I buffer di file standard non vengono scaricati. La funzione quick_exit() è sicura dei segnali quando le funzioni registrate con at_quick_exit() sono.

system

int system(const char* string);

Funzioni di allocazione della memoria

// void* aligned_alloc(size_t alignment, size_t size); // Unsupported in MSVC
void* calloc(size_t nmemb, size_t size);
void free(void* ptr);
void* malloc(size_t size);
void* realloc(void* ptr, size_t size);

Osservazioni:

Queste funzioni hanno la semantica specificata nella libreria standard C. MSVC non supporta la aligned_alloc funzione. C11 specificato aligned_alloc() in modo incompatibile con l'implementazione Microsoft di free(), vale a dire, che free() deve essere in grado di gestire allocazioni altamente allineate.

Conversioni di stringhe numeriche

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* nptr, char** endptr);
float strtof(const char* nptr, char** endptr);
long double strtold(const char* nptr, char** endptr);
long int strtol(const char* nptr, char** endptr, int base);
long long int strtoll(const char* nptr, char** endptr, int base);
unsigned long int strtoul(const char* nptr, char** endptr, int base);
unsigned long long int strtoull(const char* nptr, char** endptr, int base);

Osservazioni:

Queste funzioni hanno la semantica specificata nella libreria standard C.

Funzioni di conversione di stringhe e caratteri multibyte/wide

int mblen(const char* s, size_t n);
int mbtowc(wchar_t* pwc, const char* s, size_t n);
int wctomb(char* s, wchar_t wchar);
size_t mbstowcs(wchar_t* pwcs, const char* s, size_t n);
size_t wcstombs(char* s, const wchar_t* pwcs, size_t n);

Osservazioni:

Queste funzioni hanno la semantica specificata nella libreria standard C.

Funzioni dell'algoritmo

void* bsearch(const void* key, const void* base, size_t nmemb, size_t size, c-compare-pred * compar);
void* bsearch(const void* key, const void* base, size_t nmemb, size_t size, compare-pred * compar);
void qsort(void* base, size_t nmemb, size_t size, c-compare-pred * compar);
void qsort(void* base, size_t nmemb, size_t size, compare-pred * compar);

Osservazioni:

Queste funzioni hanno la semantica specificata nella libreria standard C.

Funzioni di generazione di numeri casuali di bassa qualità

int rand();
void srand(unsigned int seed);

Osservazioni:

Queste funzioni hanno la semantica specificata nella libreria standard C.

Valori assoluti

int abs(int j);
long int abs(long int j);
long long int abs(long long int j);
float abs(float j);
double abs(double j);
long double abs(long double j);
long int labs(long int j);
long long int llabs(long long int j);

Osservazioni:

Queste funzioni hanno la semantica specificata nella libreria standard C.

Divisione di interi

div_t div(int numer, int denom);
ldiv_t div(long int numer, long int denom);
lldiv_t div(long long int numer, long long int denom);
ldiv_t ldiv(long int numer, long int denom);
lldiv_t lldiv(long long int numer, long long int denom);

Osservazioni:

Queste funzioni hanno la semantica specificata nella libreria standard C.

Vedi anche

Riferimento file di intestazione
Panoramica sulla libreria standard C++
Thread Safety in the C++ Standard Library (Sicurezza dei thread nella libreria standard C++)