MALLOC(3)

NAME
       calloc,  malloc, free, realloc - Allocate and free dynamic
       memory

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

DESCRIPTION
       calloc() allocates memory for an array of  nmemb  elements
       of  size bytes each and returns a pointer to the allocated
       memory.  The memory is set to zero.

       malloc() allocates size bytes and returns a pointer to the
       allocated memory.  The memory is not cleared.

       free()  frees  the  memory  space pointed to by ptr, which
       must have been returned by a previous  call  to  malloc(),
       calloc()  or  realloc().   Otherwise,  or if free(ptr) has
       already been called before,  undefined  behaviour  occurs.
       If ptr is NULL, no operation is performed.

       realloc()  changes the size of the memory block pointed to
       by ptr to size bytes.  The contents will be  unchanged  to
       the minimum of the old and new sizes; newly allocated mem-
       ory will be uninitialized.  If ptr is NULL,  the  call  is
       equivalent  to malloc(size); if size is equal to zero, the
       call is equivalent to free(ptr).  Unless ptr is  NULL,  it
       must  have  been  returned by an earlier call to malloc(),
       calloc() or realloc().

RETURN VALUES
       For calloc() and malloc(), the value returned is a pointer
       to the allocated memory, which is suitably aligned for any
       kind of variable, or NULL if the request fails.

       free() returns no value.

       realloc() returns a pointer to the newly allocated memory,
       which is suitably aligned for any kind of variable and may
       be different from ptr, or NULL if the request fails or  if
       size  was  equal  to  0.   If realloc() fails the original
       block is left untouched - it is not freed or moved.

CONFORMING TO
       ANSI-C

SEE ALSO
       brk(2) 

NOTES
       Crashes in malloc(), free() or realloc() are almost always
       related  to  heap corruption, such as overflowing an allo-
       cated chunk or freeing the same pointer twice.

       Recent versions of Linux libc (later than 5.4.23) and  GNU
       libc  (2.x)  include a malloc implementation which is tun-
       able via environment  variables.   When  MALLOC_CHECK_  is
       set,  a  special  (less  efficient) implementation is used
       which is designed to be tolerant  against  simple  errors,
       such  as double calls of free() with the same argument, or
       overruns of a single byte (off-by-one bugs).  Not all such
       errors  can be proteced against, however, and memory leaks
       can result.  If MALLOC_CHECK_ is set to  0,  any  detected
       heap  corruption is silently ignored; if set to 1, a diag-
       nostic is printed on stderr;  if  set  to  2,  abort()  is
       called  immediately.  This can be useful because otherwise
       a crash may happen much later, and the true cause for  the
       problem is then very hard to track down.