<cstdlib>

Inclui o cabeçalho <stdlib.h> da biblioteca C Padrão e adiciona os nomes associados ao namespace std. A inclusão desse cabeçalho garante que os nomes declarados usando vinculação externa no cabeçalho da biblioteca C Standard sejam declarados no namespace std.

Observação

<stdlib.h> não inclui o tipo wchar_t.

Requisitos

Cabeçalho: <cstdlib>

Namespace:std

Namespace e macros

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

Funções somente exposição

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*);

Funções de início e término

Função	Descrição
_Exit	Termina o programa sem usar destruidores ou funções registradas.
abort	Termina o programa sem usar destruidores.
atexit	Registra a função para término do programa.
exit	Destrói objetos com thread e armazenamento estático e retorna o controle.
at_quick_exit	Registra a função sem argumentos para término do programa.
quick_exit	Registra a função com argumentos preservadors para término do programa.
getenv	Confira a referência da biblioteca C++ padrão.
system	Confira a referência da biblioteca C++ padrão.

_Exit

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

Comentários

O programa é terminado sem executar destruidores para objetos de duração de armazenamento automático, thread ou estático e sem funções de chamada passadas para atexit(). A função _Exit tem segurança de sinal.

abort

[[noreturn]] void abort() noexcept;

Comentários

O programa é terminado sem executar destruidores para objetos de duração de armazenamento automático, thread ou estático e sem funções de chamada passadas para atexit(). A função abort tem segurança de sinal.

at_quick_exit

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

Valor de Devolução

Zero se o registro for bem-sucedido; não zero se falhar.

Comentários

As funções at_quick_exit() registram uma função func, que é chamada sem argumentos quando quick_exit() é chamada. Uma chamada para at_quick_exit() não acontece antes que todas as chamadas a quick_exit() tenham tido êxito. As funções at_quick_exit() não introduzem uma corrida de dados. A ordem de registro poderá ser indeterminada se at_quick_exit() for chamada de mais de um thread. Como os registros at_quick_exit() são distintos dos registros atexit(), os aplicativos podem precisar chamar ambas as funções de registro usando o mesmo argumento. O MSVC dá suporte ao registro de pelo menos 32 funções.

atexit

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

Comentários

As funções atexit() registram a função apontada por func para ser chamada sem argumentos no término normal do programa. Uma chamada para atexit() não acontece antes que uma chamada a exit() tenha tido êxito. As funções atexit() não introduzem uma corrida de dados.

Valor de Devolução

Retorna zero se o registro for bem-sucedido; não zero se falhar.

exit

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

Comentários

Primeiro, objetos com duração de armazenamento de thread e associados ao thread atual são destruídos.

Em seguida, objetos com duração de armazenamento estático são destruídos e as funções registradas ao chamar atexit() são chamadas. Objetos automáticos não são destruídos quando exit() são chamados. Se o controle sair de uma função registrada chamada por exit() porque a função não fornece um manipulador para uma exceção lançada, std::terminate() será chamado. Uma função é chamada uma vez para cada vez que é registrada. Objetos com duração de armazenamento automática são todos destruídos em um programa cuja função main não contém objetos automáticos e executa a chamada para exit(). O controle pode ser transferido diretamente para essa função main gerando uma exceção que é capturada em main.

Em seguida, todos os fluxos C abertos (conforme mediado pelas assinaturas de função declaradas <cstdio>) usando dados em buffer não escritos são liberados, todos os fluxos C abertos são fechados e todos os arquivos criados ao chamar tmpfile() são removidos.

Por fim, o controle é retornado ao ambiente do host. Quando status é zero ou EXIT_SUCCESS, uma forma definida pela implementação do status de término bem-sucedido é retornada. O MSVC retorna um valor zero. Se status for EXIT_FAILURE, o MSVC retornará um valor de 3. Caso contrário, o MSVC retornará o valor de parâmetro status.

getenv

char* getenv(const char* name);

quick_exit

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

Comentários

Geralmente, as funções registradas por chamadas a at_quick_exit() são chamadas na ordem inversa de seu registro. Essa ordem não se aplica às funções registradas depois que outras funções registradas já tiverem sido chamadas. Nenhum objeto é destruído quando quick_exit() é chamado. Se o controle sair de uma função registrada chamada por quick_exit() porque a função não fornece um manipulador para uma exceção lançada, std::terminate() será chamado. Uma função registrada por meio de at_quick_exit() é invocada pelo thread que chama quick_exit(), que pode ser um thread diferente daquele que a registrou. Isso significa que as funções registradas não devem depender da identidade de objetos que têm duração de armazenamento de thread. Depois de chamar funções registradas, quick_exit() chama _Exit(status). Os buffers de arquivo padrão não são liberados. A função quick_exit() tem segurança de sinal quando as funções registradas são at_quick_exit().

system

int system(const char* string);

Funções de alocação de memória

// 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);

Comentários

Essas funções têm a semântica especificada na biblioteca padrão C. O MSVC não dá suporte à função aligned_alloc. O C11 especificou aligned_alloc() de modo que seja incompatível com a implementação da Microsoft do free(), ou seja, que free() deve ser capaz de lidar com alocações altamente alinhadas.

Conversões de cadeia de caracteres numérica

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);

Comentários

Essas funções têm a semântica especificada na biblioteca padrão C.

Funções de conversão de caracteres e cadeias de caracteres de vários bytes/largas

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);

Comentários

Essas funções têm a semântica especificada na biblioteca padrão C.

Funções de 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);

Comentários

Essas funções têm a semântica especificada na biblioteca padrão C.

Funções de geração de número aleatório de baixa qualidade

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

Comentários

Essas funções têm a semântica especificada na biblioteca padrão C.

Valores absolutos

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);

Comentários

Essas funções têm a semântica especificada na biblioteca padrão C.

Divisão de inteiros

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);

Comentários

Essas funções têm a semântica especificada na biblioteca padrão C.

Confira também

Referência de Arquivos de Cabeçalho
Visão geral da biblioteca padrão C++
Acesso Thread-Safe na Biblioteca Padrão C++