Provided by: manpages-es_1.55-8_all bug

NOMBRE

       calloc, malloc, free, realloc - Asignar y liberar memoria dinámica

SINOPSIS

       #include <stdlib.h>

       void *calloc(size_t nmemb, size_t size);
       void *malloc(size_t size);
       void free(void *ptr);
       void *realloc(void *ptr, size_t size);

DESCRIPCIÓN

       calloc()  asigna  memoria  para  una  matriz de nmemb elementos de size
       bytes cada uno y devuelve un puntero a la memoria asignada. La  memoria
       es puesta a cero.

       malloc() asigna size bytes y devuelve un puntero a la memoria asignada.
       La memoria no es borrada.

       free() libera el espacio de memoria apuntado por ptr,  que  debe  haber
       sido  devuelto por una llamada previa a malloc(), calloc() o realloc().
       En caso contrario, o si free(ptr) ya se ha llamado antes, se produce un
       comportamiento  indefinido.   Si  ptr  es  NULL,  no se realiza ninguna
       operación.

       realloc() cambia el tamaño del bloque de memoria  apuntado  por  ptr  a
       size  bytes.  El contenido permanecerá inalterado hasta el mínimo entre
       el tamaño viejo y el nuevo; la  memoria  recién  asignada  quedará  sin
       inicializar.  Si ptr es NULL, la llamada es equivalente a malloc(size);
       si size es igual a cero, la llamada es equivalente  a  free(ptr).   ptr
       debe  haber sido devuelto por una llamada previa a malloc(), calloc() o
       realloc(), a menos que ptr sea NULL.

VALOR DEVUELTO

       Para calloc() y malloc(), el valor devuelto es un puntero a la  memoria
       asignada,  que  está  convenientemente  alineada para cualquier tipo de
       variable, o NULL si la petición falla.

       free() no devuelve ningún valor.

       realloc() devuelve un puntero a la memoria recién  asignada,  que  está
       convenientemente preparada para cualquier tipo de variable y podría ser
       diferente de ptr, o NULL si la petición falla. Si size es igual a 0, se
       devuelve  o  bien  NULL  o  bien un puntero susceptible de ser pasado a
       free().Si realloc() falla el bloque original se queda como estaba -  no
       es liberado ni movido.

CONFORME A

       ANSI-C

VÉASE TAMBIÉN

       brk(2), posix_memalign(3)

OBSERVACIONES

       El  estándar Unix98 necesita que malloc(), calloc() y realloc() asignen
       a errno el valor ENOMEM en caso de fallo. Glibc asume que esto se  hace
       (y  las  versiones  de  glibc  de estas rutinas hacen esto); si usa una
       implementación privada de malloc  que  no  asinga  un  valor  a  errno,
       entonces  ciertas  rutinas de biblioteca pueden fallar sin que en errno
       aparezca el motivo del fallo.

       Los  caídas  de  malloc(),  free()  o  realloc()  casi  siempre   están
       relacionadas con la corrupción de la memoria montón (heap), tal como el
       desbordamiento de una porción de memoria reservada o la liberación  del
       mismo puntero dos veces.

       Las versiones recientes de libc de Linux (posteriores a la 5.4.23) y de
       GNU libc (2.x) incluyen una  implementación  de  malloc  que  se  puede
       ajustar  mediante variables de entorno. Cuando se define MALLOC_CHECK_,
       se usa una implementación especial (menos eficiente) que está  diseñada
       para tolerar errores simples, tales como una llamada doble a free() con
       el mismo argumento o sobrepasar un límite en un byte (fallos "fuera por
       poco"  o  de  desbordamiento).   No  obstante, no es posible protegerse
       contra todos los errores y se pueden producir pérdidas de memoria.   Si
       se  asigna  a MALLOC_CHECK_ el valor 0, cualquier corrupción de memoria
       montón detectada se ignora silenciosamente; si se le asigna el valor 1,
       se  imprime  un diagnóstico en la salida estándar de error (stderr); si
       se le asigna el valor 2, se llama inmediatamente a  abort().   Esto  es
       útil  porque,  en caso contrario, se puede producir una caída mucho más
       tarde y entonces es mucho más difícil buscar y encontrar la causa  real
       del problema.

       Linux  sigue  una  estrategia de asignación de memoria optimista.  Ésto
       significa que cuando malloc() devuelve un valor distinto de NULL no hay
       garantía  de  que  la  memoria esté realmente disponible. En caso de el
       sistema se haya quedado sin memoria, uno o más procesos  serán  matados
       por el infame asesino 00M.