C/C++编程：在堆上分配内存-------malloc()、free()、 calloc()、realloc()、memalign()、posix_memalign()

末蓝、 2022-12-27 06:29 116阅读 0赞

# 在堆上分配内存：malloc()和 free() #

一般情况下，C 程序使用 malloc 函数族在堆上分配和释放内存。较之 brk()和 sbrk()，这些函数具备不少优点，如下所示。

*  属于 C 语言标准的一部分。
 *  更易于在多线程程序中使用。
 *  接口简单，允许分配小块内存。
 *  允许随意释放内存块，它们被维护于一张空闲内存列表中，在后续内存分配调用时循环使用

在运行时分配内存的最简单标准库函数叫做`malloc`。

*  malloc( )函数在堆上分配参数 size 字节大小的内存，并返回指向新分配内存起始位置处的指针，其所分配的内存未经初始化。
 *  由于 malloc()的返回类型为 void\*，因而可以将其赋给任意类型的 C 指针。malloc()返回内存块所采用的字节对齐方式，总是适宜于高效访问任何类型的 C 语言数据结构。在大多数硬件架构上，这实际意味着 malloc 是基于 8 字节或 16 字节边界来分配内存的(此为编译器提高内存访问效率的举措之一)。
 *  若无法分配内存（或许是因为已经抵达 program break 所能达到的地址上限），则 malloc()返回 NULL，并设置 errno 以返回错误信息。虽然分配内存失败的可能性很小，但所有对 malloc()以及后续提及的相关函数的调用都应对返回值进行错误检查。

> SUSv3 规定：调用 malloc(0)要么返回 NULL，要么是一小块可以（并且应该）用 free()释放的内存。Linux 的 malloc(0)行为遵循后者

/* Allocate SIZE bytes of memory.  */
    /*
    * 参数： 需要分配的内存字节数
    * 返回值： 返回被分配的内存的第一个字节的地址。分配失败则返回null
    */
    extern void *malloc (size_t __size) __THROW __attribute_malloc__ __wur;

要释放`malloc`申请到的内存，请使用以下语句：

*  因为任何指针类型都可以自动转换这个类型，所以可以传递任何类型的指针作为参数。
 *  如果将NULL指针传递给free()函数，则该函数不执行任何操作。
 *  在调用 free()后对参数 ptr 的任何使用，例如将其再次传递给 free()，将产生错误，并可能导致不可预知的结果。

void free (void *__ptr)

一般情况下，free()并不降低program break的位置，而是将这块内存增加到空闲内存列表中，供后继的malloc循环使用。这么做是出于以下几个原因

*  被释放的内存块通常位于堆得空间，而非堆得顶部，因而降低program break是不可能的
 *  它最大限度的减少了程序必须执行的sbrk()调用次数
 *  在大多数情况下，降低 program break 的位置不会对那些分配大量内存的程序有多少帮助，因为它们通常倾向于持有已分配内存或是反复释放和重新分配内存，而非释放所有内存后再持续运行一段时间

仅当堆顶空闲内存“足够”大的时候，free()函数的 glibc 实现会调用 sbrk()来降低 program break 的地址，至于“足够”与否则取决于 malloc 函数包行为的控制参数（128 KB 为典型值）。这减少了必须对 sbrk()发起的调用次数（亦即对 brk()系统调用的调用次数）

当进程终止时，其占用的所有内存都会返还给操作系统，这包括在堆内存中由 malloc 函数包内一系列函数所分配的内存。基于内存的这一自动释放机制，对于那些分配了内存并在进程终止前持续使用的程序而言，通常会省略对 free()的调用。这在程序中分配了多块内存的情况下可能会特别有用，因为加入多次对 free()的调用不但会消耗大量的 CPU 时间，而且可能会使代码趋于复杂。

虽然依靠终止进程来自动释放内存对大多数程序来说是可以接受的，但基于以下几个原因，最好能够在程序中显式释放所有的已分配内存。

*  显式调用 free()能使程序在未来修改时更具可读性和可维护性。
 *  如果使用 malloc 调试库（如下所述）来查找程序的内存泄漏问题，那么会将任何未经显式释放处理的内存报告为内存泄漏。这会使发现真正内存泄漏的工作复杂化

## malloc()和free()的实现 ##

malloc()的实现很简单。它首先会扫描之前由free()所释放的空闲内存块列表，以求找到尺寸大于或者等于的一块空闲内存(这取决于具体实现，采用的扫描策略会不同。比如first-fit 或 best-fito）。

*  如果这一内存块的尺寸正好与要求相当，就把它直接返回给调用者。
 *  如果是一块较大的内存，那么将对其进行分割，在将一块大小相当的内存返回给调用者的同时，把较小的那块空闲内存块保留在空闲列表中

如果在空闲内存列表中根本找不到足够大的空闲内存块，那么 malloc()会调用 sbrk()以分配更多的内存。为减少对 sbrk()的调用次数，malloc()并未只是严格按所需字节数来分配内存，而是以更大幅度（以虚拟内存页大小的数倍）来增加 program break，并将超出部分置于空闲内存列表

对于free()的实现------当 free()将内存块置于空闲列表之上时，是如何知晓内存块大小的？这是通过一个小技巧来实现的。当 malloc()分配内存块时，会额外分配几个字节来存放记录这块内存大小的整数值。该整数位于内存块的起始处，而实际返回给调用者的内存地址恰好位于这一长度记录字节之后：  
![在这里插入图片描述][20210524103539840.png]  
当将内存块置于空闲内存列表（双向链表）时，free()会使用内存块本身的空间来存放链表指针，将自身添加到列表中：  
![在这里插入图片描述][20210524103630959.png]  
随着对内存不断地释放和重新分配，空闲列表中的空闲内存会和已分配的在用内存混杂在一起：  
![在这里插入图片描述][20210524103709513.png]  
应该认识到，C 语言允许程序创建指向堆中任意位置的指针，并修改其指向的数据，包括由 free()和 malloc()函数维护的内存块长度、指向前一空闲块和后一空闲块的指针。辅之以之前的描述，一旦推究起隐晦难解的编程缺陷来，这无疑形同掉进了火药桶。例如，假设经由一个错误指针，程序无意间增加了冠于一块已分配内存的长度值，并随即释放这块内存，free()因之会在空闲列表中记录下这块长度失真的内存。随后，malloc()也许会重新分配这块内存，从而导致如下场景：程序的两个指针分别指向两块它认为互不相干的已分配内存，但实际上  
这两块内存却相互重叠。至于其他的出错情况则数不胜数。

要避免这类错误，应该遵守以下规则

*  分配一块内存后，应当小心谨慎，不要改变这块内存范围外的任何内容。错误的指针运算，或者循环更新内存块内容时出现的“off-by-one”（一字之偏）错误，都有可能导致这一情况
 *  释放同一块已分配内存超过一次是错误的。Linux 上的 glibc 库经常报出分段错误（SIGSEGV 信号）。这是好事，因为它提醒我们犯下了一个编程错误。
 *  若非经由 malloc 函数包中函数所返回的指针，绝不能在调用 free()函数时使用。
 *  在编写需要长时间运行的程序（例如，shell 或网络守护进程）时，出于各种目的，如果需要反复分配内存，那么应当确保释放所有已使用完毕的内存。如若不然，堆将稳步增长，直至抵达可用虚拟内存的上限，在此之后分配内存的任何尝试都将以失败告终。这种情况被称之为“内存泄漏”。

### malloc调试的工具和库 ###

如果不遵循上述准则，可能会在代码中引入既难以理解又难以重现的缺陷。而使用 glibc提供的 malloc 调试工具或者任何一款 malloc 调试库，都会显著降低发现这些缺陷的难度，这也是设计它们的目的所在。

以下是 glibc 提供的 malloc 调试工具的部分功能

*  mtrace()和 muntrace()函数分别在程序中打开和关闭对内存分配调用进行跟踪的功能。这些函数要与环境变量 MALLOC\_TRACE 搭配使用，该变量定义了写入跟踪信息的文件名。在被调用时，mtrace()会检查是否定义了该文件，又是否可以打开文件并写入。如果一切正常，那么会在文件里跟踪和记录所有对 malloc 函数包中函数的调用。由于生成文件不易于理解，还提供有一个脚本（mtrace）用于分析文件，并生成易于理解的汇总报告。出于安全原因，设置用户 ID 和设置组 ID 的程序会忽略对 mtrace()的调用
 *  mcheck()和 mprobe()函数允许程序对已分配内存块进行一致性检查。例如，当程序试图在已分配内存之外进行写操作时，它们将捕获这个错误。这些函数提供的功能和下述 malloc 调试库有重叠之处。使用这些函数的程序，必须使用 cc-lmcheck 选项与mcheck 库链接
 *  MALLOC\_CHECK\_环境变量（注意结尾处的下划线）提供了类似于 mcheck()和mprobe()函数的功能。（两者之间的一个显著区别在于使用：MALLOC\_CHECK\_无需对程序进行修改和重新编译。）通过为此变量设置不同的整数值，可以控制程序对内存分配错误的响应方式。可能的设置有：0，意即忽略错误；1，意即在标准错误输出（stderr）中打印诊断错误；2，意即调用 abort()来终止程序。并非所有的内存分配和释放错误都是由 MALLOC\_CHECK\_检测出的，它所发现的只是常见错误。但是，这种技术快速、易用，较之于 malloc 调试库具有较低的运行时开销。出于安全原因，设置用户 ID 和设置组 ID 的程序将忽略 MALLOC\_CHECK\_设置。

关于以上所有功能更为详细的信息可以参考 glibc 手册

而就 malloc 调试库而言，其提供了和标准 malloc 函数包相同的 API，但附加了捕获内存分配错误的功能。要使用调试库，需要在编译时链接调试库，而非标准 C 函数库的 malloc 函数包。由于调试库通常会降低运行速度，增加内存消耗，或是两者兼而有之，应当仅在调试时使用，而在正式发布产品时链接标准库的 malloc 包。这些库分别是：Electric Fence（http://www.perens.com/FreeSoftware/）、dmalloc（http://dmalloc.com/）、Valgrind（http://valgrind. org/）、Insure++（http://www.parasoft.com/）

Valgrind 和 Insure++能够发现许多堆内存分配之外的其他类型错误。可以访问其各自网站，以获取详细信息

### 控制和监测 malloc 函数包 ###

glibc 手册介绍了一系列非标准函数，可用于监测和控制 malloc 包中函数的内存分配，其中包括如下几个函数。

*  函数 mallopt()能修改各项参数，以控制 malloc()所采用的算法。例如，此类参数之一就指定了在调用 sbrk()函数进行堆收缩之前，在空闲列表尾部必须保有的可释放内存空间的最小值。另一参数则规定了从堆中分配的内存块大小的上限，超出上限的内存块则使用 mmap()系统调用（参见 49.7 节）来分配。
 *  mallinfo()函数返回一个结构，其中包含由 malloc()分配内存的各种统计数据。

众多 UNIX 实现提供各种版本的 mallopt()和 mallinfo()。然而，这些函数所提供的接口却随实现而不同，因而也无法移植

## 示例 ##

### 存储int ###

int *pNumber = (int*)malloc(100);
    if(!pNumber)
    {
        
      // Code to deal with memory allocation failure . . .
    }

上面的代码请求了`100`个字节的内存，并将该内存块的地址分配给`pNumber`  
整个块可以在计算机内存保存`25`个`int`值，因为每个`int`值需要`4`个字节。

还可以这样写

int *pNumber = (int*)malloc(25*sizeof(int));
    if(!pNumber)
    {
        
      // Code to deal with memory allocation failure . . .
    }

如何释放:

free(pNumber);
    pNumber = NULL;

示例代码：

#include <stdio.h> 
    #include <stdlib.h> 
    
    int main()
    {
         
        int *age; 
    
        age = (int *)malloc(sizeof(int)*1); 
        if(age == NULL) 
        {
         
            puts("无法分配内存"); 
            exit(1); 
        } 
        printf("你今年多大了? "); 
        scanf("%d",age); 
        printf("你今年 %d 岁了.\n",*age); 
        free(pNumber);
        pNumber = NULL;
        return(0); 
    }

### 存储字符串 ###

`malloc`还可以用于创建输入缓冲区。

创建字符串的一般用法:

char input[64];

可以用以下声明代替:

char *input;

通过使用malloc()函数在代码内部建立缓冲区的大小。

#include <stdio.h> 
    #include <stdlib.h> 
    
    int main()
    {
        
        char *input;
    
        input = (char *)malloc(sizeof(char) * 1024);
        if (input == NULL)
        {
        
            puts("无法分配缓冲区!");
            exit(1);
        }
        puts("请输入一串长文字内容:");
        fgets(input, 1023, stdin);
        puts("你写入的内容是:");
        printf("%s\n", input);
        free(input );
        input = NULL;
        return(0);
    }

![在这里插入图片描述][20201208145640764.png]

### 创建结构体 ###

malloc()可用来为结构体分配存储空间。 结构体的大小通过使用sizeof运算符来确定。

#include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    
    int main()
    {
        
        struct Product {
        
            char symbol[5];
            int quantity;
            double price;
        };
        struct Product *purchase;
    
        /* 在内存中创建结构体 */
        purchase = (struct Product *)malloc(sizeof(struct Product));
        if (purchase == NULL)
        {
        
            puts("申请内存出现错误！");
            exit(1);
        }
    
        /* 分配结构体数据 */
        strncpy(purchase->symbol,"ABCD", 5);
        purchase->quantity = 100;
        purchase->price = 801.19;
    
        /* 显示结构体数据 */
        puts("投资组合如下:");
        printf("符号\t数量\t价格\t值\n");
        printf("%-6s\t%5d\t%.2f\t%.2f\n",
               purchase->symbol,
               purchase->quantity,
               purchase->price,
               purchase->quantity*purchase->price);
    
    	free(purchase);
    	purchase = NULL;
        return(0);
    }

![在这里插入图片描述][20201208145803422.png]

# calloc #

函数 calloc()用于给一组相同对象分配内存。

## 理论 ##

在stdlib.h头文件中声明的calloc()函数提供了一些优于malloc()的优点。

*  它将内存分配给给定大小的多个元素。
 *  会将已分配的内存初始化为 0。

/*
    * 参数： 
    * 		__nmemb 指定分配对象的数量
    * 		__size  指定每个对象的大小
    * 返回值：
    * 		在分配了适当大小的内存块后，calloc()返回指向这块内存起始处的指针
    *       如果无法分配内存，则返回 NULL。
    */
    void *calloc (size_t __nmemb, size_t __size)

使用 calloc()分配的内存应使用 free()来释放

## 使用 ##

类型为int的75个元素的数组分配内存:

int *pNumber = (int*) calloc(75, sizeof(int));

如果无法分配请求的内存，则返回值将为NULL。

pPrimes = calloc((size_t)total, sizeof(unsigned long long));
    if (primes == NULL)
    {
        
       printf("内存不足，看起来系统要挂掉了.\n");
       return 1;
    }

struct Product {
        
            char symbol[5];
            int quantity;
            double price;
        };
        struct Product *purchase;
    
        /* 在内存中创建结构体 */
        purchase = calloc(100, sizeof(struct Product));
        if (purchase == NULL)
        {
        
            puts("申请内存出现错误！");
            exit(1);
        }

# realloc() #

## 理论· ##

/*
    * 功能： realloc()函数重用或扩展以前使用malloc()或calloc()(或realloc())分配的内存。
    * 		将ptr指向的内存增加到size大小。如果没有足够的空间来增加，该函数会分配一段新地址，将旧地址中的内容拷贝到新地址(能拷多少拷多少)，并返回新分配的地址
    *      如果ptr是NULL，则该函数与malloc相同。
    *      如果ptr非NULL且size为0，返回一个最小大小的对象，并且旧对象被释放。
    * 参数： 
    * 	  __ptr   先前通过调用malloc()，calloc()或realloc()返回的地址的指针
    * 	  __size  要分配的新内存的大小(以字节为单位)。
    * 返回值：
    *      
    *     
    */
     void *realloc (void *__ptr, size_t __size)

realloc()函数用来调整（通常是增加）一块内存的大小，而此块内存应是之前由 malloc 包中函数所分配的

*  如果成功，realloc()返回指向大小调整后内存块的指针。与调用前的指针相比，二者指向的位置可能不同。\\
 *  如果发生错误，realloc()返回 NULL，对 ptr 指针指向的内存块则原封不动（SUSv3 要求满足这一约定）。
 *  若 realloc()增加了已分配内存块的大小，则不会对额外分配的字节进行初始化。

使用 realloc()分配的内存应使用 free()来释放

> 调用 realloc(ptr,0)等效于在 free(ptr)之后调用 malloc(0)。若 ptr 为 NULL，则 realloc(NULL, size)相当于调用 malloc(size)

通常情况下：当增大已分配内存时，realloc()会试图去合并在空闲列表中紧随其后而且大小满足要求的内存块。

*  如果原内存块位于堆得顶部，那么realloc()将会对堆空间进行扩展。
 *  如果原内存位于堆的中部，且紧邻其后的空闲内存空间大小不足，realloc()会分配一块新内存，并将原有数据复制到新内存块中。

最后这种情况最为常见，还会占用大量 CPU资源。一般情况下，应尽量避免调用 realloc()。

既然 realloc()可能会移动内存，对这块内存的后续引用就必须使用 realloc()的返回指针。可以用 realloc()来重新定位由变量 ptr 指向的内存块，代码如下

nptr = realloc(ptr, newsize);
    if(nptr == null){
        
    	// 处理错误
    }else{
        
    	ptr = null;
    }

由于 realloc()可能会移动内存块，任何指向该内存块内部的指针在调用 realloc()之后都可能不再可用。仅有一种内存块内的位置引用方法依然有效，即以指向此块内存起始处的指针再加上一个偏移量来进行定位。

## 实践 ##

#include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    
    int main()
    {
        
        char *input;
        int len = 1024;
    
        input = (char *)malloc(sizeof(char) * len);
        if (input == NULL)
        {
        
            puts("申请内存失败，可能内存不够用了!");
            exit(1);
        }
        puts("请输入一个长字符串:");
        fgets(input, len - 1, stdin);
        len = strlen(input);
        printf("after fgets, strlen(input)  = %d\n", len);
        if (realloc(input, sizeof(char)*(len + 1)) == NULL)
        {
        
            puts("申请内存失败，可能内存不够用了!");
            exit(1);
        }
        puts("内存重新分配.");
        puts("你写入的内容是:");
        printf("%s\n", input);
    
        return(0);
    }

# 分配对齐的内存：memalign()和 posix\_memalign() #

设计函数 memalign()和 posix\_memalign()的目的在于分配内存时，起始地址要与 2 的整数次幂边界对齐，该特征对于某些应用非常有用

#include <malloc.h>
    
    void *memalign(size_t alignment, size_t size);

函数 memalign()分配 size 个字节的内存，起始地址是参数 boundary 的整数倍，而 boundary必须是 2 的整数次幂。函数返回已分配内存的地址。

函数 memalign()并非在所有 UNIX 实现上都存在。大多数提供 memalign()的其他 UNIX 实现都要求引用< stdlib.h>而非< malloc.h>以获得函数声明。

SUSv3 并未纳入 memalign()，而是规范了一个类似函数，名为posix\_memalign()。该函数由标准委员会于近期创制，只是出现在了少数 UNIX 实现上

#include <stdlib.h>
    
    int posix_memalign(void **memptr, size_t alignment, size_t size);

函数 posix\_memalign()与 memalign()存在以下两方面的不同。

*  已分配的内存地址通过参数 memptr 返回。
 *  内存块的起始地址是 alignment 参数的整数倍。alignment 必须是 sizeof（void\*）（在大多数硬件架构上是 4 或 8 个字节）与 2 的整数次幂两者间的乘积。

还要注意该函数与众不同的返回值，出错时不是返回−1，而是直接返回一个错误号（即通常在 errno 中返回的正整数）。

如果 SizeOf(void \*)为 4，就可以使用 posix\_memalign()分配 65536 字节的内存，并与 4096字节的边界对齐，代码如下：

int s;
    void *memptr;
    
    s = posix_memalign(&memptr, 1024*sizeof(void *), 65526);
    if(s != 0){
        
         // handler error
    }

由 memalign()或 posix\_memalign()分配的内存块应该调用 free()来释放

<table> 
 <thead> 
  <tr> 
   <th>理论</th> 
   <th>原型</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>malloc</td> 
   <td>void * malloc(size_t size);</td> 
   <td>分配size大小的内存</td> 
  </tr> 
  <tr> 
   <td>calloc</td> 
   <td>void * calloc(size_t count, size_t size);</td> 
   <td>分配count个对象的内存，每个对象为size大小。分配的内存被清零</td> 
  </tr> 
  <tr> 
   <td>valloc</td> 
   <td>void * realloc(void *ptr, size_t size);</td> 
   <td>分配size大小的内存。The allocated memory is aligned on a page boundary。</td> 
  </tr> 
  <tr> 
   <td>realloc</td> 
   <td>void * realloc(void *ptr, size_t size)</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>reallocf</td> 
   <td>void * reallocf(void *ptr, size_t size)</td> 
   <td>与realloc不同在于，如果分配失败，该函数会释放旧内存。</td> 
  </tr> 
 </tbody> 
</table>

如果出现错误，(除free)则返回NULL并设置errno为ENOMEM。

对于realloc函数，如果内存分配失败，旧内存可用。

对于reallocf函数，如果内存分配失败，旧内存也会被释放。

# 总结 #

#include <stdlib.h>
    /*
    * 功能： 分配指定字节数的存储区。此存储区的初始值不确定
    * 返回值： 成功，返回非空指针（可以用于任何数据对象），不成功，返回NULL
    * 		  
    */
    void *malloc (size_t __size)
    /*
    * 功能： 为指定数量指定长度的对象分配存储已经被初始化为0的空间
    * 返回值： 成功，返回非空指针（可以用于任何数据对象），不成功，返回NULL
    */
    void *calloc (size_t __nmemb, size_t __size)
    /*
    * 功能： 增加或者减少以前分配区的长度。增加的空间初始值不确定
    * 参数： __size为存储区的新长度
    *       __ptr如果为null，功能与malloc相同
    * 返回值： 成功，返回非空指针（可以用于任何数据对象），不成功，返回NULL
    */
    void *realloc (void *__ptr, size_t __size)
    
    /*
    * 功能：是否ptr指向的空间，被释放的空间被送入可用存储区池，可以被重新分配
    *      如果一个空间被malloc但是忘记free，那么该进程占用的存储空间越来越大，这就叫做泄漏
    */
    void free (void *__ptr)

[20210524103539840.png]: /images/20221120/000d5b3ef56940cd9d489d20f0bda352.png
[20210524103630959.png]: https://img-blog.csdnimg.cn/20210524103630959.png
[20210524103709513.png]: https://img-blog.csdnimg.cn/20210524103709513.png
[20201208145640764.png]: https://img-blog.csdnimg.cn/20201208145640764.png
[20201208145803422.png]: https://img-blog.csdnimg.cn/20201208145803422.png