Name

g_new()

#define     g_new(struct_type, n_structs)

Allocates n_structs elements of type struct_type. The returned pointer is cast to a pointer to the given type. If n_structs is 0 or if memory allocation failure takes place, it returns NULL.

Since the returned pointer is already casted to the right type, it is normally unnecessary to cast it explicitly, and doing so might hide memory allocation errors.

g_new0()

#define     g_new0(struct_type, n_structs)

Allocates n_structs elements of type struct_type, initialized to 0's. The returned pointer is cast to a pointer to the given type. If n_structs is 0 or if memory allocation failure takes place, it returns NULL.

Since the returned pointer is already casted to the right type, it is normally unnecessary to cast it explicitly, and doing so might hide memory allocation errors.

g_renew()

#define     g_renew(struct_type, mem, n_structs)

Reallocates the memory pointed to by mem, so that it now has space for n_structs elements of type struct_type. It returns the new address of the memory, which may have been moved. If memory allocation failure takes place it returns NULL.

g_try_new()

#define     g_try_new(struct_type, n_structs)

Attempts to allocate n_structs elements of type struct_type, and returns NULL on failure.  Contrast with g_new(), which aborts the program on failure. The returned pointer is cast to a pointer to the given type. If n_structs is 0 it returns NULL.

g_try_new0()

#define     g_try_new0(struct_type, n_structs)

Attempts to allocate n_structs elements of type struct_type, initialized to 0's, and returns NULL on failure. Contrast with g_new0(), which aborts the program on failure.  The returned pointer is cast to a pointer to the given type. If n_counts is 0 it returns NULL.

g_try_renew()

#define     g_try_renew(struct_type, mem, n_structs)

Attempts to reallocate the memory pointed to by mem, so that it now has space for n_structs elements of type struct_type, and returns NULL on failure. Contrast with g_renew(), which aborts the program on failure. It returns the new address of the memory, which may have been moved. 

g_malloc ()

gpointer    g_malloc        (gulong n_bytes);

Allocates n_bytes bytes of memory. If n_bytes is 0 or if memory allocation failure takes place, it returns NULL.

g_malloc0 ()

gpointer    g_malloc0      (gulong n_bytes);

Allocates n_bytes bytes of memory, initialized to 0's. If n_bytes is 0 or if memory allocation failure takes place, it returns NULL.

g_realloc ()

gpointer    g_realloc          (gpointer mem, gulong n_bytes);

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 or if memory allocation failure takes place, NULL will be returned.

g_try_malloc ()

gpointer    g_try_malloc        (gulong n_bytes);

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

g_try_malloc0 ()

gpointer    g_try_malloc0      (gulong n_bytes);

Attempts to allocate n_bytes, initialized to 0's, and returns NULL on failure.

Since 2.8

g_try_realloc ()

gpointer    g_try_realloc       (gpointer mem, gulong n_bytes);

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. If mem is NULL, behaves the same as g_try_malloc().

g_free ()

void        g_free          (gpointer mem);

Frees the memory pointed to by mem. If mem is NULL it simply returns.

extern gboolean g_mem_gc_friendly;

g_alloca()

#define     g_alloca(size)

The function alloca() is not supported in Open C.  This macro essentially just wraps the g_malloc() function present in libglib and allocates memory on the heap. The allocated memory must be freed using g_free().

g_newa()

#define     g_newa(struct_type, n_structs)

Wraps g_alloca() in a more typesafe manner.

g_memmove()

#define     g_memmove(dest,src,len)

Copies a block of memory len bytes long, from src to dest. The source and destination areas may overlap.

In order to use this function, include string.h , because this macro will typically simply resolve to memmove() and GLib does not include string.h.

g_memdup ()

gpointer    g_memdup         (gconstpointer mem, guint byte_size);

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

GMemVTable

typedef struct {
  gpointer (*malloc)      (gsize    n_bytes);
  gpointer (*realloc)     (gpointer mem, gsize  n_bytes);
  void     (*free)        (gpointer mem);
  /* optional; set to NULL if not used ! */

  gpointer (*calloc)      (gsize    n_blocks, gsize  n_block_bytes);
  gpointer (*try_malloc)  (gsize    n_bytes);
  gpointer (*try_realloc) (gpointer mem, gsize  n_bytes);
} GMemVTable;

A set of functions used to perform memory allocation. The same GMemVTable must be used for all allocations in the same program; a call to g_mem_set_vtable(), if it exists, should be prior to any use of GLib.

g_mem_set_vtable ()

void        g_mem_set_vtable      (GMemVTable *vtable);

Sets the GMemVTable to use for memory allocation.Use this to provide custom memory allocation routines. This function must be called before using any other GLib functions. The vtable only needs to provide malloc(), realloc(), and free() functions; GLib can provide default implementations of the others. The malloc() and realloc() implementations should return NULL on failure, GLib will handle error-checking. vtable is copied, so need not persist after this function has been called.

g_mem_is_system_malloc ()

gboolean    g_mem_is_system_malloc    (void);

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 interchangeable 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.

A different allocator can be set using g_mem_set_vtable().

glib_mem_profiler_table

extern GMemVTable	*glib_mem_profiler_table;

A GMemVTable containing profiling variants of the memory allocation functions. Use them together with g_mem_profile() in order to get information about the memory allocation pattern of the program. To access this variable application include glib_global.h.

g_mem_profile ()

void        g_mem_profile          (void);

Outputs a summary of memory usage.

It outputs the frequency of allocations of different sizes, the total number of bytes which have been allocated, the total number of bytes which have been freed, and the difference between the previous two values, i.e. the number of bytes still in use.

Note that this function will not output anything unless the glib_mem_profiler_table with g_mem_set_vtable() has been previously installed.

Feedback

For additional information or queries on this page send feedback