Memory

Members

Static functions

clearPointer

void clearPointer(void** pp, GDestroyNotify destroy)

Clears a reference to a variable.

free

void free(void* mem)

Frees the memory pointed to by mem.

malloc

void* malloc(size_t nBytes)

Allocates n_bytes bytes of memory. If n_bytes is 0 it returns NULL.

malloc0

void* malloc0(size_t nBytes)

Allocates n_bytes bytes of memory, initialized to 0's. If n_bytes is 0 it returns NULL.

malloc0N

void* malloc0N(size_t nBlocks, size_t nBlockBytes)

This function is similar to g_malloc0(), allocating (n_blocks * n_block_bytes) bytes, but care is taken to detect possible overflow during multiplication.

mallocN

void* mallocN(size_t nBlocks, size_t nBlockBytes)

This function is similar to g_malloc(), allocating (n_blocks * n_block_bytes) bytes, but care is taken to detect possible overflow during multiplication.

memIsSystemMalloc

bool memIsSystemMalloc()

Checks whether the allocator used by g_malloc() is the system's malloc implementation. If it returns TRUE memory allocated with malloc() can be used interchangeably with memory allocated using g_malloc(). This function is useful for avoiding an extra copy of allocated memory returned by a non-GLib-based API.

memProfile

void memProfile()

GLib used to support some tools for memory profiling, but this no longer works. There are many other useful tools for memory profiling these days which can be used instead.

memSetVtable

void memSetVtable(GMemVTable* vtable)

This function used to let you override the memory allocation function. However, its use was incompatible with the use of global constructors in GLib and GIO, because those use the GLib allocators before main is reached. Therefore this function is now deprecated and is just a stub.

memdup

void* memdup(void* mem, uint byteSize)

Allocates byte_size bytes of memory, and copies byte_size bytes into it from mem. If mem is NULL it returns NULL.

realloc

void* realloc(void* mem, size_t nBytes)

Reallocates the memory pointed to by mem, so that it now has space for n_bytes bytes of memory. It returns the new address of the memory, which may have been moved. mem may be NULL, in which case it's considered to have zero-length. n_bytes may be 0, in which case NULL will be returned and mem will be freed unless it is NULL.

reallocN

void* reallocN(void* mem, size_t nBlocks, size_t nBlockBytes)

This function is similar to g_realloc(), allocating (n_blocks * n_block_bytes) bytes, but care is taken to detect possible overflow during multiplication.

tryMalloc

void* tryMalloc(size_t nBytes)

Attempts to allocate n_bytes, and returns NULL on failure. Contrast with g_malloc(), which aborts the program on failure.

tryMalloc0

void* tryMalloc0(size_t nBytes)

Attempts to allocate n_bytes, initialized to 0's, and returns NULL on failure. Contrast with g_malloc0(), which aborts the program on failure.

tryMalloc0N

void* tryMalloc0N(size_t nBlocks, size_t nBlockBytes)

This function is similar to g_try_malloc0(), allocating (n_blocks * n_block_bytes) bytes, but care is taken to detect possible overflow during multiplication.

tryMallocN

void* tryMallocN(size_t nBlocks, size_t nBlockBytes)

This function is similar to g_try_malloc(), allocating (n_blocks * n_block_bytes) bytes, but care is taken to detect possible overflow during multiplication.

tryRealloc

void* tryRealloc(void* mem, size_t nBytes)

Attempts to realloc mem to a new size, n_bytes, and returns NULL on failure. Contrast with g_realloc(), which aborts the program on failure.

tryReallocN

void* tryReallocN(void* mem, size_t nBlocks, size_t nBlockBytes)

This function is similar to g_try_realloc(), allocating (n_blocks * n_block_bytes) bytes, but care is taken to detect possible overflow during multiplication.

• Memory