Memory Allocation

Memory Allocation — Основная обработка памяти.

Краткое описание



#include <glib.h>


#define     g_new                           (struct_type, n_structs)
#define     g_new0                          (struct_type, n_structs)
#define     g_renew                         (struct_type, mem, n_structs)
#define     g_try_new                       (struct_type, n_structs)
#define     g_try_new0                      (struct_type, n_structs)
#define     g_try_renew                     (struct_type, mem, n_structs)

gpointer    g_malloc                        (gulong n_bytes);
gpointer    g_malloc0                       (gulong n_bytes);
gpointer    g_realloc                       (gpointer mem,
                                             gulong n_bytes);
gpointer    g_try_malloc                    (gulong n_bytes);
gpointer    g_try_malloc0                   (gulong n_bytes);
gpointer    g_try_realloc                   (gpointer mem,
                                             gulong n_bytes);

void        g_free                          (gpointer mem);
extern      gboolean g_mem_gc_friendly;

#define     g_alloca                        (size)
#define     g_newa                          (struct_type, n_structs)

#define     g_memmove                       (dest,src,len)
gpointer    g_memdup                        (gconstpointer mem,
                                             guint byte_size);

            GMemVTable;
void        g_mem_set_vtable                (GMemVTable *vtable);
gboolean    g_mem_is_system_malloc          (void);

extern      GMemVTable	*glib_mem_profiler_table;
void        g_mem_profile                   (void);

Описание

Эти функции обеспечивают поддержку распределения и освобождения памяти.

Примечание

Если любой вызов распределения памяти завершается неудачно, приложение закрывается. Это означает что нет необходимости проверять успешность выполнения вызова.

Детали

g_new()

#define g_new(struct_type, n_structs)

Распределяет n_structs элементов типа struct_type. Возвращаемый указатель приводится к указателю для данного типа. Если n_structs равен 0, то возвращается NULL.

Так как возвращаемый указатель уже приведён к правильному типу, обычно не требуется явное приведение, это может скрыть ошибки распределения памяти.

`struct_type` :	тип элементов для распределения.
`n_structs` :	количество элементов для распределения.
Возвращает :	указатель для распределенной памяти, приведённый к указателю типа `struct_type`.

g_new0()

#define g_new0(struct_type, n_structs)

Распределяет n_structs элементов типа struct_type, инициализирует в 0's. Возвращаемый указатель приведён к указателю полученного типа. Если n_structs равен 0 возвращается NULL.

`struct_type` :	тип элементов для распределения.
`n_structs` :	количество элементов для распределения.
Возвращает :	указатель для распределённой памяти, приведённый к указателю типа `struct_type`.

g_renew()

#define g_renew(struct_type, mem, n_structs)

Перераспределяет память указанную параметром mem, так чтобы она имела свободное пространство для n_structs элементов типа struct_type. Возвращает новый адрес памяти, которая возможно была перемещена.

`struct_type` :	тип элементов для распределения.
`mem` :	текущая распределённая память.
`n_structs` :	количество элементов для распределения.
Возвращает :	указатель на вновь распределенную память, приведен к указателю типа `struct_type`.

g_try_new()

#define g_try_new(struct_type, n_structs)

Пытается распределить n_structs элементов типа struct_type и возвращает NULL если неудаётся. В отличие от g_new(), которая закрывает программу при неудаче. Возвращаемый указатель приведён к указателю полученного типа. Если n_structs равен 0 возвращается NULL.

`struct_type` :	тип элементов для распределения.
`n_structs` :	количество элементов для рапределения.
Возвращает :	указатель на распределенную память, приведённый к указателю типа `struct_type`.

Начиная с версии 2.8

g_try_new0()

#define g_try_new0(struct_type, n_structs)

Пытается распределить n_structs элементов типа struct_type, инициализируя 0 и возвращает NULL при неудаче. В отличие от g_new0(), которая закрывает программу при неудаче. Возвращаемый указатель приводится к указателю полученного типа. Если n_counts равен 0, то возвращается NULL.

`struct_type` :	тип элементов для распределения.
`n_structs` :	количество элементов для рапределения.
Возвращает :	указатель на распределенную память, приведённый к указателю типа `struct_type`.

Начиная с версии 2.8

g_try_renew()

#define g_try_renew(struct_type, mem, n_structs)

Пытается перераспределить память указанную параметром mem, так чтобы появилось пространство для n_structs элементов типа struct_type и возвращает NULL при неудаче. В отличие от g_renew(), которая закрывает программу при неудаче. Возвращает новый адрес памяти, которая могла быть перемещена.

`struct_type` :	тип элементов для распределения.
`mem` :	текущее распределение памяти.
`n_structs` :	количество элементов для рапределения.
Возвращает :	указатель на вновь распределённую память, приведённый к указателю типа `struct_type`.

Начиная с версии 2.8

g_malloc ()

gpointer g_malloc (gulong n_bytes);

Распределяет n_bytes байт памяти. Если n_bytes равен 0, возвращает NULL.

`n_bytes` :	количество байт для распределения.
Возвращает :	указатель на распределённую память.

g_malloc0 ()

gpointer g_malloc0 (gulong n_bytes);

Распределяет n_bytes байт памяти, инициализируя 0's. Если n_bytes равен 0, возвращает NULL.

`n_bytes` :	количество байт для распределения.
Возвращает :	указатель на распределённую память.

g_realloc ()

gpointer    g_realloc                       (gpointer mem,
                                             gulong n_bytes);

Перераспределяет память указанную параметром mem, так чтобы было свободное пространство для n_bytes байт памяти. Возвращает новый адрес памяти, которая могла быть перемещена. mem может быть NULL, в этом случае предполагается нулевая длина. n_bytes может быть 0, в этом случае возвращается NULL.

`mem` :	память для перераспределения.
`n_bytes` :	новый размер памяти в байтах.
Возвращает :	новый адрес распределённой памяти.

g_try_malloc ()

gpointer g_try_malloc (gulong n_bytes);

Пытается распределить n_bytes, и возвращает NULL при неудаче. В отличие от g_malloc(), которая закрывает программу при неудаче.

`n_bytes` :	количество байт для распределения.
Возвращает :	распределённую память или `NULL`.

g_try_malloc0 ()

gpointer g_try_malloc0 (gulong n_bytes);

Пытается распределить n_bytes, инициализируя 0's, и возвращает NULL при неудаче. В отличие от g_malloc0(), которая закрывает программу при неудаче.

`n_bytes` :	количество байт для распределения.
Возвращает :	распределённую память или `NULL`.

Начиная с версии 2.8

g_try_realloc ()

gpointer    g_try_realloc                   (gpointer mem,
                                             gulong n_bytes);

Пытается перераспределить mem в новый размер n_bytes, и возвращает NULL при неудаче. В отличие от g_realloc(), которая закрывает программу при неудаче. Если mem равен NULL, работает также как g_try_malloc().

`mem` :	предварительно распределённая память, или `NULL`.
`n_bytes` :	количество байт для распределения.
Возвращает :	распределённую память или `NULL`.

g_free ()

void g_free (gpointer mem);

Освобождает память указанную параметром mem. Если mem равен NULL, то функция ничего не делает.

mem : память для освобождения.

g_mem_gc_friendly

extern gboolean g_mem_gc_friendly;

Эта переменная равна TRUE если переменная окружения G_DEBUG включает ключ gc-friendly.

g_alloca()

#define g_alloca(size)

Распределяет size байт в стек; эти байты освобождаются когда текущий кадр стека очищается. Этот макрос по существу просто оболочка функции alloca() предоставляемой в большинстве вариантов UNIX. Поэтому он обеспечивает те же самые преимущества и ловушки как alloca():

	+ `alloca()` очень быстрая, так как на большинстве систем она выполняет просто регулировку регистра указателей стека.
	+ она не вызывает фрагментации памяти, в пределах её области, разделяемые `alloca()` блоки просто увеличиваются и освобождаются одновременно с завершением функции.
	- распределяемый размер должен вписываться в текущий кадр стека. Например в потоковом окружении Linux, размер стека посредством потока ограничен 2 мегабайтами, поэтому разряжен при использовании `alloca()`.
	- неудачное распределение из-за недостатка пространства в стеке не указывается возвращением `NULL` как например это происходит при использовании `malloc()`. Вместо этого, большинство систем вероятно обработает это так же как отсутствие свободного пространства стека из бесконечной рекурсивной функции, то есть произойдет ошибка сегментации (segmentation fault).
	- особое внимание должно быть уделено при смешивании `alloca()` с массивами переменного размера GNU C. Распределённое пространство стека с помощью `alloca()` в той же области где массив переменного размера, будет освобождено вместе с массивом переменного размера при выходе из этой области, а не на выходе внешней области функции.

`size` :	количество байт для распределения.
Возвращает :	пространство для `size` байт, распределяемое в стеке

g_newa()

#define g_newa(struct_type, n_structs)

Оболочка g_alloca() в более типо-безопасной манере.

`struct_type` :	тип участка памяти для распределения
`n_structs` :	Количество участков для распределения
Возвращает :	указатель на пространство стека для `n_structs` участков типа `struct_type`

g_memmove()

#define g_memmove(dest,src,len)

Копирует блок памяти длиной len байт, из src в dest. Источник и адресат могут перекрываться.

Для использования этой функции вы должны самостоятельно включить string.h, потому что этот макрос обычно простое решение для memmove() и GLib не будет включать string.h за вас.

`dest` :	адресат для копируемых байт.
`src` :	источник копируемых байт.
`len` :	количество копируемых байт.

g_memdup ()

gpointer    g_memdup                        (gconstpointer mem,
                                             guint byte_size);

Распределяет byte_size байт памяти и копирует byte_size байт из mem. Если mem равен NULL возвращается NULL.

`mem` :	память для копирования.
`byte_size` :	количество копируемых байт.
Возвращает :	указатель на вновь распределенную копию памяти, или `NULL` если параметр `mem` равен `NULL`.

GMemVTable

typedef struct {
  gpointer (*malloc)      (gsize    n_bytes);
  gpointer (*realloc)     (gpointer mem,
			   gsize    n_bytes);
  void     (*free)        (gpointer mem);
  /* опционально; устанавливается в NULL если не используется! */
  gpointer (*calloc)      (gsize    n_blocks,
			   gsize    n_block_bytes);
  gpointer (*try_malloc)  (gsize    n_bytes);
  gpointer (*try_realloc) (gpointer mem,
			   gsize    n_bytes);
} GMemVTable;

Устанавливает функцию используемую для распределения памяти. Также GMemVTable может использоваться для всех распределений в той же самой программе; вызов g_mem_set_vtable(), если он существует, должен быть приоритетным для любого использования GLib.

`malloc` ()	функция используемая для распределения памяти.
`realloc` ()	функция используемая для перераспределения памяти.
`free` ()	функция используемая для освобождения памяти.
`calloc` ()	функция используемая для распределения памяти заполняемой нулями (allocating zero-filled memory).
`try_malloc` ()	функция используемая для распределения памяти без обработки ошибок по умолчанию.
`try_realloc` ()	функция используемая для перераспределения памяти без обработки ошибок по умолчанию.

g_mem_set_vtable ()

void g_mem_set_vtable (GMemVTable *vtable);

Заставляет GMemVTable использовать для распределения памяти. Вы можете это использовать для обеспечения выбора функций распределения памяти. Эти функции должны вызываться перед использованием любых других функций GLib. Параметр vtable нужен только для обеспечения malloc(), realloc(), и free() функций; GLib может по умолчанию обеспечить реализацию других. Реализации malloc() и realloc() должны возвращать NULL при неудаче, GLib обрабатывает контроль ошибок за вас. vtable копируется, поэтому не сохраняется после вызова этой функции.

vtable : таблица функций распределения памяти.

g_mem_is_system_malloc ()

gboolean g_mem_is_system_malloc (void);

Проверяет использует ли программа распределения памяти g_malloc() системную реализацию malloc. Если возвращает TRUE память распределяемая с помощью malloc() взаимозаменяема памятью распределяемой с использованием g_malloc(). Эта функция полезна для избежания дополнительных копий распределения памяти возвращаемой с помощью не-GLib-based API.

Разные функции распределения могут быть установлены с помощью g_mem_set_vtable().

Возвращает : если TRUE, malloc() и g_malloc() могут использоваться совместно.

glib_mem_profiler_table

extern GMemVTable	*glib_mem_profiler_table;

GMemVTable содержит профилированные варианты функций распределения памяти. Используйте их вместе с g_mem_profile() для получения информации об образце распределения памяти вашей программой.

g_mem_profile ()

void g_mem_profile (void);

Определяет суммарное использование памяти.

Она выдаёт частоту распределений различных размеров, общее количество распределённых байт, общее количество освобождённых байт и разницу между двумя предыдущими значениями, то есть количество всё ещё используемых байт.

Помните что эта функция не определит ничего пока вы предварительно не установите glib_mem_profiler_table с помощью g_mem_set_vtable().

			Справочное описание GLib
Начало \| Описание