Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages


home | help
MALLOC(3)		   Linux Programmer's Manual		     MALLOC(3)

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

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

       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().	Other-
       wise, or	if free(ptr) has already been called before, undefined	behav-
       iour 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 memory 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().

       For calloc() and	malloc(), the value returned is	a pointer to the allo-
       cated  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. 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.


       brk(2), posix_memalign(3)

       The  Unix98  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(), free() or	realloc() 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	GNU libc (2.x)
       include a malloc	implementation which is	tunable	via environment	 vari-
       ables.  When MALLOC_CHECK_ is set, a special (less efficient) implemen-
       tation 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  protected
       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
       diagnostic is printed on	stderr;	if set to 2, abort() is	called immedi-
       ately.  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

       Linux follows an	optimistic memory  allocation  strategy.   This	 means
       that when malloc() returns non-NULL there is no guarantee that the mem-
       ory really is available.	In case	it turns out that the system is	out of
       memory,	one  or	 more  processes  will	be  killed by the infamous OOM

GNU				  1993-04-04			     MALLOC(3)


Want to link to this manual page? Use this URL:

home | help