malloc, free, calloc, realloc, reallocarray - allocate and free dynamic memory
#include <stdlib.h>
void *malloc(size_t size);
void free(void *_Nullable ptr);
void *calloc(size_t nmemb, size_t size);
void *realloc(void *_Nullable ptr, size_t size);
void *reallocarray(void *_Nullable ptr, size_t nmemb, size_t size);
Feature Test Macro Requirements for glibc (see feature_test_macros(7)):
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 a unique pointer value that can later be successfully passed to
free(). (See "Nonportable behavior" for portability
issues.)
The free() function frees the memory space pointed
to by ptr
, which must have been returned by a previous call to
malloc() or related functions. Otherwise, or if
ptr
has already been freed, 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 a unique pointer value that can later be successfully passed to
free().
If the multiplication of nmemb
and size
would
result in integer overflow, then calloc() returns an
error. By contrast, an integer overflow would not be detected in the
following call to malloc(), with the result that an
incorrectly sized block of memory would be allocated:
malloc(nmemb * size);
The realloc() function changes the size of the
memory block pointed to by ptr
to size
bytes. The
contents of the memory 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
malloc(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)
(but see "Nonportable
behavior" for portability issues).
Unless ptr
is NULL, it must have been returned by an earlier
call to malloc or related functions. If the area
pointed to was moved, a free(ptr)
is done.
The reallocarray() function changes the size of (and
possibly moves) the memory block pointed to by ptr
to be large
enough for an array of nmemb
elements, each of which is
size
bytes. It is equivalent to the call
realloc(ptr, nmemb * size);
However, unlike that realloc() call, reallocarray() fails safely in the case where the multiplication would overflow. If such an overflow occurs, reallocarray() returns an error.
The malloc(), calloc(),
realloc(), and reallocarray()
functions return a pointer to the allocated memory, which is suitably
aligned for any type that fits into the requested size or less. On
error, these functions return NULL and set errno
. Attempting to
allocate more than PTRDIFF_MAX bytes is considered an
error, as an object that large could cause later pointer subtraction to
overflow.
The free() function returns no value, and preserves
errno
.
The realloc() and reallocarray()
functions return NULL if ptr
is not NULL and the requested size
is zero; this is not considered an error. (See "Nonportable behavior"
for portability issues.) Otherwise, the returned pointer may be the same
as ptr
if the allocation was not moved (e.g., there was room to
expand the allocation in-place), or different from ptr
if the
allocation was moved to a new address. If these functions fail, the
original block is left untouched; it is not freed or moved.
#include <err.h>
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MALLOCARRAY(n, type) ((type *) my_mallocarray(n, sizeof(type)))
#define MALLOC(type) MALLOCARRAY(1, type)
static inline void *my_mallocarray(size_t nmemb, size_t size);
int
main(void)
{
char *p;
p = MALLOCARRAY(32, char);
if (p == NULL)
err(EXIT_FAILURE, "malloc");
strlcpy(p, "foo", 32);
puts(p);
}
static inline void *
my_mallocarray(size_t nmemb, size_t size)
{
return reallocarray(NULL, nmemb, size);
}
valgrind(1), 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)
For details of the GNU C library implementation, see https://sourceware.org/glibc/wiki/MallocInternals">.