Namespaces
Variants

Standard library header <cstdlib>

From cppreference.net
Standard library headers

Este encabezado estaba originalmente en la biblioteca estándar de C como <stdlib.h> .

Este encabezado proporciona utilidades misceláneas. Los símbolos definidos aquí son utilizados por varios componentes de la biblioteca.

Contenidos

Tipos

tipo de estructura, devuelto por std::div
(typedef)
tipo de estructura, devuelto por std::ldiv
(typedef)
(C++11)
tipo de estructura, devuelto por std::lldiv
(typedef)
tipo entero sin signo devuelto por el operador sizeof
(typedef)

Constantes de macro

indica el estado de ejecución del programa
(macro constante)
MB_CUR_MAX
número máximo de bytes en un carácter multibyte con la configuración regional actual
(macro constante)
constante de puntero nulo definida por la implementación
(constante macro)
valor máximo posible generado por std::rand
(constante macro)

Funciones

Control de procesos
provoca la terminación anormal del programa (sin limpieza)
(función)
provoca la terminación normal del programa con limpieza
(función)
(C++11)
provoca la terminación rápida del programa sin una limpieza completa
(función)
(C++11)
causa la terminación normal del programa sin limpieza
(función)
registra una función para ser llamada en std::exit() invocación
(función)
registra una función para ser llamada en std::quick_exit invocación
(función)
llama al procesador de comandos del entorno anfitrión
(función)
acceso a la lista de variables de entorno
(función)
Gestión de memoria
asigna memoria
(función)
asigna memoria alineada
(función)
asigna y pone a cero la memoria
(función)
expande o reduce el bloque de memoria previamente asignado
(función)
desasigna memoria previamente asignada
(función)
Conversión numérica de cadenas
convierte una cadena de bytes a un valor de punto flotante
(función)
convierte una cadena de bytes a un valor entero
(función)
convierte una cadena de bytes a un valor entero
(función)
convierte una cadena de bytes a un valor entero sin signo
(función)
convierte una cadena de bytes a un valor de punto flotante
(función)
Manipulación de cadenas anchas
devuelve el número de bytes en el siguiente carácter multibyte
(función)
convierte el siguiente carácter multibyte a carácter ancho
(función)
convierte un carácter ancho a su representación multibyte
(función)
convierte una cadena de caracteres multibyte estrecha a cadena ancha
(función)
convierte una cadena ancha a una cadena de caracteres multibyte estrecha
(función)
Algoritmos y matemáticas diversos
genera un número pseudoaleatorio
(función)
inicializa el generador de números pseudoaleatorios
(función)
ordena un rango de elementos con tipo no especificado
(función)
busca un elemento de tipo no especificado en un arreglo
(función)
calcula el valor absoluto de un valor integral ( |x| )
(función)
calcula el cociente y el resto de la división entera
(función)

Sinopsis

namespace std {
  using size_t =  /* ver descripción */; // freestanding
  using div_t =   /* ver descripción */; // freestanding
  using ldiv_t =  /* ver descripción */; // freestanding
  using lldiv_t = /* ver descripción */; // freestanding
}
#define NULL         /* ver descripción */ // freestanding
#define EXIT_FAILURE /* ver descripción */ // freestanding
#define EXIT_SUCCESS /* ver descripción */ // freestanding
#define RAND_MAX     /* ver descripción */
#define MB_CUR_MAX   /* ver descripción */
namespace std {
  // Alias de tipos de función solo para exposición
  extern "C" using /* c-atexit-handler */ = void(); // exposición solamente
  extern "C++" using /* manejador atexit */ = void(); // exposición solamente
  extern "C" using /* c-compare-pred */ =           // exposición solamente
    int(const void*, const void*);
  extern "C++" using /* comparar-predicado */ =           // exposición solamente
    int(const void*, const void*);
  // inicio y terminación
  [[noreturn]] void abort() noexcept;                       // freestanding
  int atexit(/* c-atexit-handler */* func) noexcept;        // freestanding
  int atexit(/* manejador atexit */* func) noexcept;          // freestanding
  int at_quick_exit(/* c-atexit-handler */* func) noexcept; // freestanding
  int at_quick_exit(/* manejador atexit */* func) noexcept;   // freestanding
  [[noreturn]] void exit(int status);                       // freestanding
  [[noreturn]] void _Exit(int status) noexcept;             // freestanding
  [[noreturn]] void quick_exit(int status) noexcept;        // freestanding
  char* getenv(const char* name);
  int system(const char* string);
  // Asignación de memoria de la biblioteca C
  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);
  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);
  // funciones de conversión de cadenas y caracteres multibyte/ancho
  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);
  // Algoritmos de la biblioteca estándar de C
  void* bsearch(const void* key, const void* base,  // freestanding
                size_t nmemb, size_t size, /* c-compare-pred */* compar);
  void* bsearch(const void* key, const void* base,  // freestanding
                size_t nmemb, size_t size, /* comparar-predicado */* compar);
  void qsort(void* base, size_t nmemb, size_t size, // freestanding
             /* c-compare-pred */* compar);
  void qsort(void* base, size_t nmemb, size_t size, // freestanding
             /* comparar-predicado */* compar);
  // generación de números aleatorios de baja calidad
  int rand();
  void srand(unsigned int seed);
  // valores absolutos
  constexpr int abs(int j);                       // freestanding
  constexpr long int abs(long int j);             // freestanding
  constexpr long long int abs(long long int j);   // freestanding
  constexpr /* tipo de punto flotante */
    abs(/* tipo de punto flotante */ j);             // freestanding-deleted
  constexpr long int labs(long int j);            // freestanding
  constexpr long long int llabs(long long int j); // freestanding
  constexpr div_t div(int numer, int denom);                         // freestanding
  constexpr ldiv_t div(long int numer, long int denom);              // freestanding
  constexpr lldiv_t div(long long int numer, long long int denom);   // freestanding
  constexpr ldiv_t ldiv(long int numer, long int denom);             // freestanding
  constexpr lldiv_t lldiv(long long int numer, long long int denom); // freestanding
}

Informes de defectos

Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares de C++ publicados anteriormente.

DR Aplicado a Comportamiento publicado Comportamiento correcto
LWG 286 C++98 la definición de size_t no se proporcionaba en <cstdlib> proporcionada

Véase también