malloc,realloc,calloc的介绍与区别

一.首先我们先大体介绍下 malloc ralloc calloc

1.malloc   

       void* malloc(size_t size );

分配size个字节的未初始化的存储空间。

如果分配成功则返回指向被分配内存的指针(此存储区中的初始值不确定)，否则返回空指针NULL。当内存不再使用时，应使用free()函数将内存块释放。函数返回的指针一定要适当对齐，使其可以用于任何数据对象

<span style="font-size:14px;">#include <stdlib.h> 
#include <stdio.h>                                                                                                                
int main(void) 
{
    int *p1 = malloc(4*sizeof(int));  // allocates enough for an array of 4 int
    int *p2 = malloc(sizeof(int[4])); // same, naming the type directly
    int *p3 = malloc(4*sizeof *p3);   // same, without repeating the type name
 
    if(p1)                                                                                                                           {
        for(int n=0; n<4; ++n) // populate the array
       ｛                                                                                                                                    p1[n] = n*n;                                                                                                                 ｝
        for(int n=0; n<4; ++n) // print it back out
       ｛                                                                                                                                    printf("p1[%d] == %d\n", n, p1[n]);
        }
    ｝                                                                                                                                     
    free(p1);
    free(p2);
    free(p3);
</span>

三者的执行结果都是

p1[0] == 0
p1[1] == 1
p1[2] == 4
p1[3] == 9

2.calloc

       void* calloc(size_t num, size_t size );

为大小为size的num对象的数组分配内存，并对其清零。

如果分配成功，返回指向分配内存块最低（第一个）字节的指针，且其对所有的目标类型都进行适当地对齐。

如果size为零，其行为由实现定义（可能返回空指针，也可能返回某个不能用来访问存储空间的非空指针）。

  

<span style="font-size:14px;">#include <stdio.h>                                                                                                               #include <stdlib.h>
 
int main(void)
{
    int *p1 = calloc(4, sizeof(int));    // allocate and zero out an array of 4 int
    int *p2 = calloc(1, sizeof(int[4])); // same, naming the array type directly
    int *p3 = calloc(4, sizeof *p3);     // same, without repeating the type name
 
    if(p2)                                                                                                                           {
        for(int n=0; n<4; ++n) // print the array
        {                                                                                                                                     printf("p2[%d] == %d\n", n, p2[n]);
        }                                                                                                                            }
 
    free(p1);
    free(p2);
    free(p3);
</span>

三者的结果都是

p2[0] == 0
p2[1] == 0
p2[2] == 0
p2[3] == 0

3.realloc

void*realloc(void*ptr,size_t new_size );

重新分配给定的内存区域。该区域必须之前曾被malloc()、calloc()或realloc()所分配并且未被free()所释放，否则，其结果是未定义的。

重新分配以下面两者之一完成：

a) 扩大或收缩目前ptr所指向的区域，若可能的话。区域中的内容保持不变，直至到达新旧大小中较小的一个。如果区域被扩大，数组中新部分的内容是未定义的。

b) 分配一个新的new_size字节大的内存块，将和新旧大小中较小的一个一样大的内存区域复制过来，并释放旧的块。

如果内存不足，旧的内存块不会被释放并且返回空指针。

<span style="font-size:14px;">#include <stdio.h>
#include <stdlib.h>
 
int main(void)
{
    int *pa = malloc(10 * sizeof *pa); // allocate an array of 10 int
    if(pa)                                                                                                                           {
        printf("%zu bytes allocated. Storing ints: ", 10*sizeof(int));
        for(int n = 0; n < 10; ++n)
        {                                                                                                                                     printf("%d ", pa[n] = n);
        }                                                                                                                            }
 
    int *pb = realloc(pa, 1000000 * sizeof *pb); // reallocate array to a larger size
                                                                                                                                     if(pb)                                                                                                                           {
        printf("\n%zu bytes allocated, first 10 ints are: ", 1000000*sizeof(int));
        for(int n = 0; n < 10; ++n)
        {                                                                                                                                        printf("%d ", pb[n]); // show the array
        }                                                                                                                                free(pb);
    }                                                                                                                                else                                                                                                                             {     // if realloc failed, the original pointer needs to be freed
        free(pa);
    }
}</span>

输出结果为

40 bytes allocated. Storing ints: 0 1 2 3 4 5 6 7 8 9
4000000 bytes allocated, first 10 ints are: 0 1 2 3 4 5 6 7 8 9

二.函数的大体使用以及原理已简介，接下来就是三者的区别，换言之，总结对比吧。

calloc - 分配内存、把内存清零。

malloc - 分配内存、不把内存清零。

realloc - 重新分配内存，把之前的数据搬到新内存去。

———————

realloc(NULL, size) 等价于 malloc(size)。

calloc(num, size) 基本上等于 void *p = malloc(num * size); memset(p, 0, num * size); 但理论上 calloc 的实现可避免 num * size 溢出，当溢出时返回 NULL 代表失败，而 malloc(num * size) 可能会分配了一个尺寸溢出后的内存。

———————

具体一点，区别如下：

   (1)函数malloc不能初始化所分配的内存空间,而函数calloc能.如果由malloc()函数分配的内存空间原来没有被使用过，则其中的每一位可能都是0;反之, 如果这部分内存曾经被分配过,则其中可能遗留有各种各样的数据.也就是说，使用malloc()函数的程序开始时(内存空间还没有被重新分配)能正常进行,但经过一段时间(内存空间还已经被重新分配)可能会出现问题.
    (2)函数calloc() 会将所分配的内存空间中的每一位都初始化为零,也就是说,如果你是为字符类型或整数类型的元素分配内存,那么这些元素将保证会被初始化为0;如果你是为指针类型的元素分配内存,那么这些元素通常会被初始化为空指针;如果你为实型数据分配内存,则这些元素会被初始化为浮点型的零.
    (3)函数malloc向系统申请分配指定size个字节的内存空间.返回类型是 void*类型.void*表示未确定类型的指针.C,C++规定，void* 类型可以强制转换为任何其它类型的指针.
    (4)realloc可以对给定的指针所指的空间进行扩大或者缩小，无论是扩张或是缩小，原有内存的中内容将保持不变.当然，对于缩小，则被缩小的那一部分的内容会丢失.realloc并不保证调整后的内存空间和原来的内存空间保持同一内存地址.相反，realloc返回的指针很可能指向一个新的地址.
    (5)realloc是从堆上分配内存的.当扩大一块内存空间时，realloc()试图直接从堆上现存的数据后面的那些字节中获得附加的字节，如果能够满足，自然天下太平；如果数据后面的字节不够，问题就出来了，那么就使用堆上第一个有足够大小的自由块，现存的数据然后就被拷贝至新的位置，而老块则放回到堆上.这句话传递的一个重要的信息就是数据可能被移动.

————————————————————————————————————————————————————————————————————

接下来补充一个malloc在Linux上(其他系统上没有验证)的特性吧。当malloc需要分配内存大小超过512KB(32位系统)或4*sizeof(long)MB(64位系统)时，所分配的内存区域一定会被全0填充。此时，再通过memset全0填充就浪费时间了。原因如下  

在Linux上，glibc的这些内存分配函数对大内存的分配和小内存的分配采取完全不同的两种行为。当分配内存较小时，内存分配函数在堆上分配内存。此时，堆内存可能在之前被使用过，所以你得到的内存区域可能含有杂乱的数据。但是当分配内存较大时，这些函数直接通过mmap系统调用进行内存映射。这时，操作系统处于安全考虑，会强制全0填充这块内存。所以你得到的内存区域一定是全0填充过的。函数通过与mallopt的M_MMAP_THRESHOLD选项进行比较，判定你要分配大内存块还是小内存块。你可以通过mallopt()或环境变量来设置M_MMAP_THRESHOLD，默认值是128KB。它的大小不会超过DEFAULT_MMAP_THRESHOLD_MAX。DEFAULT_MMAP_THRESHOLD_MAX在32位系统上是512KB，在64位系统上是4*sizeof(long) MB