Toll Free Numbers
  • Last 5 Forum Topics
    Last post

The Web Only This Site



  • MARC

    Mailing list ARChives
    - Search by -


    Computing Dictionary

  • Text Link Ads
  • LINUX man pages
  • Linux Man Page Viewer

    The following form allows you to view linux man pages.





           #include <stdlib.h>
           void *malloc(size_t size);
           void free(void *ptr);
           void *calloc(size_t nmemb, size_t size);
           void *realloc(void *ptr, size_t size);


           The malloc() function allocates size bytes and returns a pointer to the
           allocated memory.  The memory is not initialized.  If size is  0,  then
           malloc()  returns either NULL, or a unique pointer value that can later
           be successfully passed to free().
           The free() function 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  behavior occurs.  If ptr is NULL, no operation is performed.
           The calloc() function 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.  If nmemb or size is 0,  then  calloc()  returns
           either  NULL,  or a unique pointer value that can later be successfully
           passed to free().
           The realloc() function changes the size of the memory block pointed  to
           by ptr to size bytes.  The contents will be unchanged in the range from
           the start of the region up to the minimum of the old and new sizes.  If
           the  new size is larger than the old size, the added memory will not be
           initialized.  If ptr is NULL, then  the  call  is  equivalent  to  mal-
           loc(size), for all values of size; if size is equal to zero, and ptr is
           not NULL, then the call is equivalent  to  free(ptr).   Unless  ptr  is
           NULL,  it  must have been returned by an earlier call to malloc(), cal-
           loc() or realloc().  If the area pointed to was moved, a  free(ptr)  is


           The  malloc()  and calloc() functions return a pointer to the allocated
           memory, which is suitably aligned for any  built-in  type.   On  error,
           these functions return NULL.  NULL may also be returned by a successful
           call to malloc() with a size of zero, or by a successful call  to  cal-
           loc() with nmemb or size equal to zero.
           The free() function returns no value.
           The realloc() function returns a pointer to the newly allocated memory,
           which is suitably aligned for any built-in type and  may  be  different
           from ptr, or NULL if the request fails.  If size was equal to 0, either
           NULL or a pointer suitable to be passed  to  free()  is  returned.   If
           realloc()  fails  the original block is left untouched; it is not freed
           or moved.
           ory larger than MMAP_THRESHOLD bytes, the glibc malloc() implementation
           allocates  the  memory  as  a  private anonymous mapping using mmap(2).
           MMAP_THRESHOLD is 128 kB by  default,  but  is  adjustable  using  mal-
           lopt(3).   Allocations  performed  using  mmap(2) are unaffected by the
           RLIMIT_DATA resource limit (see getrlimit(2)).
           To avoid corruption in multithreaded  applications,  mutexes  are  used
           internally to protect the memory-management data structures employed by
           these functions.  In  a  multithreaded  application  in  which  threads
           simultaneously  allocate and free memory, there could be contention for
           these mutexes.  To scalably handle memory allocation  in  multithreaded
           applications,  glibc  creates  additional  memory  allocation arenas if
           mutex contention is detected.  Each arena is a large region  of  memory
           that  is  internally allocated by the system (using brk(2) or mmap(2)),
           and managed with its own mutexes.
           The UNIX 98 standard requires malloc(), calloc(), and realloc() to  set
           errno to ENOMEM upon failure.  Glibc assumes that this is done (and the
           glibc versions of these routines do this); if you use a private  malloc
           implementation  that  does not set errno, then certain library routines
           may fail without having a reason in errno.
           Crashes in malloc(), calloc(), realloc(), or free() are  almost  always
           related  to  heap corruption, such as overflowing an allocated chunk or
           freeing the same pointer twice.
           Recent versions of Linux libc  (later  than  5.4.23)  and  glibc  (2.x)
           include  a  malloc()  implementation  which  is tunable via environment
           variables.  For details, see mallopt(3).


           brk(2), mmap(2), alloca(3), malloc_get_state(3), malloc_info(3),
           malloc_trim(3), malloc_usable_size(3), mallopt(3), mcheck(3),
           mtrace(3), posix_memalign(3)

    GNU 2013-12-12 MALLOC(3)


  • Linux

    The Distributions


    The Software


    The News


  • Toll Free

Toll Free Numbers
Copyright © 1999 - 2016 by LinuxGuruz