Provided by: manpages-es_1.55-4_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 ini‐
        cializar.  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 real     
        loc(), a menos que ptr sea NULL.
        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.
        ANSI-C
        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 ajus‐
        tar  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 con‐
        tra 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.