Glib学习（19）内存分配 Memory Allocation

Myth丶恋晨 2022-02-13 15:27 1569阅读 0赞

glib源码下载：http://ftp.gnome.org/pub/gnome/sources/glib/  
glib帮助文档：https://developer.gnome.org/glib/

本节主要讲解一下Memory Allocation函数，基本就是linux系统函数的封装，我把函数使用谷歌翻译了一下，没有仔细校验，因为英语是在太差，而且函数基本差不多，懂了一个就能举一反三。基本都是实际使用的函数，就不提供例程了。

Includes  
\#include <glib.h>

描述

这些函数支持分配和释放内存。  
如果任何分配内存的调用失败，则终止应用程序。 这也意味着无需检查调用是否成功。  
将g\_malloc（）（包括封装为 g\_new()）与g\_free（）匹配很重要，g\_slice\_alloc（）（包括封装为 g\_slice\_new()）与g\_slice\_free（），普通malloc（）与free（），（如果你使用的是C ++）new 与 delete和new \[\] 与 delete \[\]。否则会发生不好的事情，因为这些分配器可能使用不同的内存池（而且new / delete调用构造函数和析构函数）。

函数

**g\_new()**

\#define             g\_new(struct\_type, n\_structs)  
分配类型为struct\_type的n\_structs元素。 返回的指针被强制转换为指向给定类型的指针。 如果n\_structs为0，则返回NULL。 在计算分配块的大小时，要注意避免溢出。  
由于返回的指针已经被转换为正确的类型，因此通常不需要显式地转换它，这样做可能会隐藏内存分配错误。  
参数  
struct\_type  
要分配的元素的类型  
n\_structs  
要分配的元素数量  
返回值  
指向已分配内存的指针，强制转换为指向struct\_type的指针

**g\_new0()**  
\#define             g\_new0(struct\_type, n\_structs)  
分配n\_structs类型为struct\_type的元素，初始化为0。 返回的指针被强制转换为指向给定类型的指针。 如果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)  
尝试分配struct\_type类型的n\_structs元素，并在失败时返回NULL。 与g\_new（）对比，g\_new（）在失败时中止程序。 返回的指针被强制转换为指向给定类型的指针。 如果发生溢出，则n\_structs为0时，该函数返回NULL。  
参数  
struct\_type  
要分配的元素的类型  
n\_structs  
要分配的元素数量  
返回值  
指向新分配的内存的指针，强制转换为指向struct\_type的指针

**g\_try\_new0()**  
\#define             g\_try\_new0(struct\_type, n\_structs)  
尝试分配struct\_type类型的n\_structs元素，初始化为0，并在失败时返回NULL。 与g\_new0（）对比，g\_new0（）在失败时中止程序。 返回的指针被强制转换为指向给定类型的指针。 当n\_structs为0或发生溢出时，该函数返回NULL。  
参数  
struct\_type  
要分配的元素的类型  
n\_structs  
要分配的元素数量  
返回值  
指向新分配的内存的指针，强制转换为指向struct\_type的指针

**g\_try\_renew()**  
\#define             g\_try\_renew(struct\_type, mem, n\_structs)  
尝试重新分配mem指向的内存，以便它现在为n\_structs类型为struct\_type的元素提供空间，并在失败时返回NULL。 与g\_renew（）对比，它在失败时中止程序。 它返回可能已被移动的内存的新地址。 如果发生溢出，该函数返回NULL。  
参数  
struct\_type  
要分配的元素的类型  
mem  
当前分配的内存  
n\_structs  
要分配的元素数量  
返回值  
指向新分配的内存的指针，强制转换为指向struct\_type的指针

**g\_malloc ()**  
gpointer  
g\_malloc (gsize n\_bytes);  
分配n\_bytes个字节的内存。 如果n\_bytes为0，则返回NULL。  
参数  
n\_bytes  
要分配的字节数  
返回值  
当前分配的内存  
**g\_malloc0 ()**  
gpointer  
g\_malloc0 (gsize n\_bytes);  
分配n\_bytes个字节的内存，初始化为0。 如果n\_bytes为0，则返回NULL。  
参数  
n\_bytes  
要分配的字节数  
返回值  
指向已分配内存的指针

**g\_realloc ()**  
gpointer  
g\_realloc (gpointer mem,  
           gsize n\_bytes);  
重新分配mem指向的内存，以便它现在有n\_bytes字节的内存空间。 它返回可能已被移动的内存的新地址。 mem可能为NULL，在这种情况下，它被认为是零长度。 n\_bytes可能为0，在这种情况下，将返回NULL并释放mem，除非它为NULL。  
参数  
mem  
要重新分配的内存。  
\[nullable\]  
n\_bytes  
新的内存大小（以字节为单位）  
返回值  
已分配内存的新地址

**g\_try\_malloc ()**  
gpointer  
g\_try\_malloc (gsize n\_bytes);  
尝试分配n\_bytes，并在失败时返回NULL。 与g\_malloc（）对比，后者在失败时中止程序。  
参数  
n\_bytes  
要分配的字节数。  
返回值  
分配的内存，或NULL。

**g\_try\_malloc0 ()**  
gpointer  
g\_try\_malloc0 (gsize n\_bytes);  
尝试分配n\_bytes，初始化为0，并在失败时返回NULL。 与g\_malloc0（）对比，后者在失败时中止程序。  
参数  
n\_bytes  
要分配的字节数。  
返回值  
分配的内存，或NULL。

**g\_try\_realloc ()**  
gpointer  
g\_try\_realloc (gpointer mem,  
               gsize n\_bytes);  
尝试将mem重新分配给新大小n\_bytes，并在失败时返回NULL。 与g\_realloc（）对比，它在失败时中止程序。  
如果mem为NULL，则行为与g\_try\_malloc（）相同。  
参数  
mem  
先前分配的内存，或NULL。  
\[nullable\]  
n\_bytes  
要分配的字节数。  
返回值  
分配的内存，或NULL。

**g\_malloc\_n ()**  
gpointer  
g\_malloc\_n (gsize n\_blocks,  
            gsize n\_block\_bytes);  
此函数类似于g\_malloc（），分配（n\_blocks \* n\_block\_bytes）个字节，但要注意检测乘法期间可能的溢出。  
参数  
n\_blocks  
要分配的块数  
n\_block\_bytes  
每个块的大小（以字节为单位）  
返回值  
指向已分配内存的指针

**g\_malloc0\_n ()**  
gpointer  
g\_malloc0\_n (gsize n\_blocks,  
             gsize n\_block\_bytes);  
此函数类似于g\_malloc0（），分配（n\_blocks \* n\_block\_bytes）字节，但要注意检测乘法期间可能的溢出。  
参数  
n\_blocks  
要分配的块数  
n\_block\_bytes  
每个块的大小（以字节为单位）  
返回值  
指向已分配内存的指针

**g\_realloc\_n ()**  
gpointer  
g\_realloc\_n (gpointer mem,  
             gsize n\_blocks,  
             gsize n\_block\_bytes);  
此函数类似于g\_realloc（），分配（n\_blocks \* n\_block\_bytes）字节，但要注意检测乘法期间可能的溢出。  
参数  
mem  
要重新分配的内存。  
\[nullable\]  
n\_blocks  
要分配的块数  
n\_block\_bytes  
每个块的大小（以字节为单位）  
返回值  
已分配内存的新地址

**g\_try\_malloc\_n ()**  
gpointer  
g\_try\_malloc\_n (gsize n\_blocks,  
                gsize n\_block\_bytes);  
此函数类似于g\_try\_malloc（），分配（n\_blocks \* n\_block\_bytes）个字节，但要注意检测乘法期间可能的溢出。  
参数  
n\_blocks  
要分配的块数  
n\_block\_bytes  
每个块的大小（以字节为单位）  
返回值  
分配的内存，或NULL。

**g\_try\_malloc0\_n ()**  
gpointer  
g\_try\_malloc0\_n (gsize n\_blocks,  
                 gsize n\_block\_bytes);  
此函数类似于g\_try\_malloc0（），分配（n\_blocks \* n\_block\_bytes）个字节，但要注意检测乘法期间可能的溢出。  
参数  
n\_blocks  
要分配的块数  
n\_block\_bytes  
每个块的大小（以字节为单位）  
返回值  
分配的内存，或NULL

**g\_try\_realloc\_n ()**  
gpointer  
g\_try\_realloc\_n (gpointer mem,  
                 gsize n\_blocks,  
                 gsize n\_block\_bytes);  
此函数类似于g\_try\_realloc（），分配（n\_blocks \* n\_block\_bytes）个字节，但要注意检测乘法期间可能的溢出。  
参数  
mem  
先前分配的内存，或NULL。  
\[nullable\]  
n\_blocks  
要分配的块数  
n\_block\_bytes  
每个块的大小（以字节为单位）  
返回值  
分配的内存，或NULL。

**g\_free ()**  
void  
g\_free (gpointer mem);  
释放mem指向的内存。  
如果mem为NULL，则它只返回，因此在调用此函数之前无需检查mem对NULL。  
参数  
mem  
要释放的记忆。  
\[nullable\]  
**g\_clear\_pointer ()**  
void  
g\_clear\_pointer (gpointer \*pp,  
                 GDestroyNotify destroy);  
清除对变量的引用。  
pp不能为NULL。  
如果引用为NULL，则此函数不执行任何操作。 否则，使用destroy销毁变量，并将指针设置为NULL。  
还包括一个宏，允许在没有指针强制转换的情况下使用此函数。  
\[skip\]

参数  
pp  
指向保存指针的变量，结构成员等的指针。  
\[not nullable\]  
destroy  
可以传递gpointer的函数，以销毁\* pp**g\_steal\_pointer ()**  
gpointer  
g\_steal\_pointer (gpointer pp);  
将pp设置为NULL，返回之前的值。  
从概念上讲，这将指针的所有权从引用的变量转移到宏的“调用者”（即：“窃取”引用）。  
根据pp的类型，将正确键入返回值。  
当与g\_autoptr（）结合使用时，这可以非常有用，以防止自动释放函数的返回值。 考虑以下示例（仅适用于GCC和clang）：

GObject *
    create_object (void)
    {
      g_autoptr(GObject) obj = g_object_new (G_TYPE_OBJECT, NULL);
    
      if (early_error_case)
        return NULL;
    
      return g_steal_pointer (&obj);
    }

它也可以以类似的方式用于'out'参数，对于处理可选的out参数特别有用：

gboolean
    get_object (GObject **obj_out)
    {
      g_autoptr(GObject) obj = g_object_new (G_TYPE_OBJECT, NULL);
    
      if (early_error_case)
        return FALSE;
    
      if (obj_out)
        *obj_out = g_steal_pointer (&obj);
    
      return TRUE;
    }

在上面的示例中，对象将在早期错误情况下自动释放，并且在为obj\_out指定NULL的情况下也会自动释放。  
参数  
pp  
指向指针的指针。  
\[not nullable\]

**g\_alloca()**  
\#define             g\_alloca(size)  
在堆栈上分配大小字节; 清除当前堆栈帧时将释放这些字节。 这个宏基本上只包含大多数UNIX变种上存在的alloca（）函数。 因此它提供了与alloca（）相同的优点和缺陷：  
alloca（）速度非常快，因为在大多数系统中，它只需调整堆栈指针寄存器即可实现。  
它不会导致任何内存碎片，在其范围内，单独的alloca（）块只是构建并在函数端一起释放。  
分配大小必须适合当前的堆栈帧。 例如，在Linux上的线程环境中，每线程堆栈大小限制为2兆字节，因此使用alloca（）时需要注意大小。  
由于堆栈空间不足而导致的分配失败不会像NULL返回那样表示，例如 使用malloc（）。 相反，大多数系统可能以与无限函数递归的堆栈空间情况相同的方式处理它，即具有分段错误。  
将alloca（）与GNU C变量大小的数组混合时，必须特别小心。 在与可变大小的数组相同的范围内使用alloca（）分配的堆栈空间将在退出该作用域时与可变大小的数组一起释放，而不是在封闭的函数作用域退出时释放。  
参数  
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)  
g\_memmove自版本2.40起已被弃用，不应在新编写的代码中使用。

**g\_memdup ()**  
gpointer  
g\_memdup (gconstpointer mem,  
          guint byte\_size);  
分配内存的byte\_size字节，并将mem\_s中的byte\_size字节复制到其中。 如果mem为NULL，则返回NULL。  
参数  
mem  
要复制的内存。  
byte\_size  
要复制的字节数。  
返回值  
指向新分配的内存副本的指针，如果mem为NULL，则为NULL。

**g\_mem\_set\_vtable ()**  
void  
g\_mem\_set\_vtable (GMemVTable \*vtable);  
g\_mem\_set\_vtable自版本2.46起已被弃用，不应在新编写的代码中使用。

**g\_mem\_is\_system\_malloc ()**  
gboolean  
g\_mem\_is\_system\_malloc (void);  
g\_mem\_is\_system\_malloc自版本2.46起已被弃用，不应在新编写的代码中使用。

**g\_mem\_profile ()**  
void  
g\_mem\_profile (void);  
g\_mem\_profile自版本2.46起已被弃用，不应在新编写的代码中使用。

Types and Values  
g\_mem\_gc\_friendly  
extern gboolean g\_mem\_gc\_friendly;

如果G\_DEBUG环境变量包含密钥gc-friendly，则此变量为TRUE。

**struct GMemVTable**  
struct GMemVTable \{  
  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; 对g\_mem\_set\_vtable（）的调用（如果存在）应该在使用GLib之前。  
与此相关的功能已在2.46中弃用，不再有效。

**glib\_mem\_profiler\_table**  
extern GMemVTable \*glib\_mem\_profiler\_table;  
glib\_mem\_profiler\_table自版本2.46起已被弃用，不应在新编写的代码中使用。