malloc, free, realloc, calloc, alloca - memory allocator

void *malloc(size)
size_t size;

void free(ptr)
void *ptr;

void *realloc(ptr, size)
void *ptr;
size_t size;

void *calloc(nelem, elsize)
size_t nelem, elsize;

void *alloca(size)
size_t size;

Malloc and free provide a general-purpose memory allocation
package. Malloc returns a pointer to a block of at least size
bytes beginning on a word boundary.

The argument to free is a pointer to a block previously allocated
by malloc; this space is made available for further allocation, but
its contents are left undisturbed.

Needless to say, grave disorder will result if the space assigned
by malloc is overrun or if some random number is handed to free.

Malloc maintains a list of free blocks sorted by size, allocating
space from the first block of appropriate size. It calls sbrk (see
brk(2)) to get more memory from the system when there is no
suitable space already free.

Realloc changes the size of the block pointed to by ptr to size
bytes and returns a pointer to the (possibly moved) block. The
contents will be unchanged up to the lesser of the new and old

In order to be compatible with older versions, realloc also works
if ptr points to a block freed since the last call of malloc,
realloc or calloc; sequences of free, malloc and realloc were
previously used to attempt storage compaction. This procedure is
no longer recommended.

Calloc allocates space for an array of nelem elements of size
elsize. The space is initialized to zeros.

Alloca allocates size bytes of space in the stack frame of the
caller. This temporary space is automatically freed on return.

Each of the allocation routines returns a pointer to space suitably
aligned (after possible pointer coercion) for storage of any type
of object.


Malloc, realloc and calloc return a null pointer (0) if there is no
available memory or if the arena has been detectably corrupted by
storing outside the bounds of a block. Malloc may be recompiled to
check the arena very stringently on every transaction; those sites
with a source code license may check the source code to see how
this can be done.

When realloc returns 0, the block pointed to by ptr may be

The current implementation of malloc does not always fail
gracefully when system memory limits are approached. It may fail
to allocate memory when larger free blocks could be broken up, or
when limits are exceeded because the size is rounded up. It is
optimized for sizes that are powers of two.

Alloca is machine dependent; its use is discouraged.