malloc和calloc之间的区别？

两者之间有什么区别：

ptr = (char **) malloc (MAXELEMS * sizeof(char *));

要么：

ptr = (char **) calloc (MAXELEMS, sizeof(char*));

什么时候在malloc上使用calloc是个好主意，反之亦然？

calloc()给您一个零初始化的缓冲区，而未初始化malloc()的内存。

对于较大的分配，calloc主流操作系统下的大多数实现都将从操作系统（例如，通过POSIX mmap(MAP_ANONYMOUS)或Windows VirtualAlloc）获得已知为零的页面，因此无需在用户空间中写入它们。这也是正常情况下malloc从操作系统获取更多页面的方式。calloc只是利用了操作系统的保证。

这意味着calloc内存仍然可以“清理”和延迟分配，并且写时复制映射到系统范围的零共享物理页。（假定系统具有虚拟内存。）

一些编译器甚至可以为您优化malloc + memset（0）到calloc中，但是如果您希望将内存读取为，则应显式使用calloc 0。

如果您不打算在写入之前读取内存，请使用它，malloc以便（可能）从其内部空闲列表中为您提供脏内存，而不是从操作系统中获取新页面。（或者不是将空闲列表上的内存块清零以进行少量分配）。

如果没有操作系统，或者不是花哨的多用户操作系统将页面清零以阻止进程之间的信息泄漏，则的嵌入式实现calloc可能会将其calloc自身留给零内存。

在嵌入式Linux上，可以对malloc mmap(MAP_UNINITIALIZED|MAP_ANONYMOUS)启用，因为仅在某些嵌入式内核中启用了malloc ，因为它在多用户系统上不安全。

一个鲜为人知的区别是，在具有乐观内存分配的操作系统（例如Linux）中，malloc直到程序真正接触到它之后，返回的指针才由实内存支持。

calloc确实确实触及了内存（它在内存上写了零），因此您可以确定操作系统正在支持具有实际RAM（或交换）的分配。这也是为什么它比malloc慢的原因（不仅必须将其清零，而且操作系统还必须通过交换其他进程来找到合适的内存区域）

例如，请参见此SO问题以进一步讨论malloc的行为

一个经常被忽略的优点calloc是（符合要求的实现）它将帮助您防止整数溢出漏洞。相比：

size_t count = get_int32(file);
struct foo *bar = malloc(count * sizeof *bar);

与

size_t count = get_int32(file);
struct foo *bar = calloc(count, sizeof *bar);

如果前者count大于，则前者可能会导致很小的分配和随后的缓冲区溢出SIZE_MAX/sizeof *bar。在这种情况下，后者将自动失败，因为无法创建较大的对象。

当然，您可能需要寻找不符合标准的实现，而这些实现只是忽略了溢出的可能性...如果您所针对的平台存在此问题，则无论如何都必须手动进行溢出测试。

文档使calloc看起来像malloc，它只是对内存进行零初始化。这不是主要区别！calloc的想法是抽象用于存储分配的写时复制语义。当您使用calloc分配内存时，所有内存都映射到相同的物理页面，该页面初始化为零。当将已分配内存的任何页面写入一个物理页面时。这通常用于制作巨大的哈希表，例如，因为哈希的空白部分没有任何额外的内存（页面）支持；他们高兴地指向单个零初始化页面，该页面甚至可以在进程之间共享。

对虚拟地址的任何写入都将映射到一个页面，如果该页面是零页面，则分配了另一个物理页面，零页面被复制到该页面，并且控制流返回到客户端进程。这与内存映射文件，虚拟内存等的工作方式相同。它使用分页。

这是有关该主题的一个优化故事：http : //blogs.fau.de/hager/2007/05/08/benchmarking-fun-with-calloc-and-zero-pages/

分配的内存块大小没有差异。calloc只是用物理全零位模式填充内存块。在实践中，通常假定分配给内存块中的对象calloc具有初始值，就好像它们是用文字初始化的一样0，即整数应具有的值0，浮点变量的值-的值0.0，指针的值-适当的空指针值， 等等。

但是，从书呆子的角度来看，calloc（和memset(..., 0, ...)）只能保证正确初始化（使用零）类型的对象unsigned char。其他所有内容都不能保证正确初始化，并且可能包含所谓的陷阱表示，这会导致未定义的行为。换句话说，对于除unsigned char上述全零位patterm 以外的任何类型，都可能表示非法值，陷阱表示。

后来，在C99的技术勘误中之一，为所有整数类型定义了行为（这是有道理的）。即，在形式上，在当前的C语言中，您只能使用calloc（和memset(..., 0, ...)）初始化整数类型。从C语言的角度来看，一般情况下使用它来初始化其他任何东西都会导致未定义的行为。

实际上，calloc众所周知，）是可行的，但是，是否要使用它（考虑以上内容）则取决于您。我个人更喜欢完全避免使用它，malloc而是使用它并执行自己的初始化。

最后，另一个重要的细节是calloc在内部通过将元素大小乘以元素数来计算最终块大小。这样做时，calloc必须注意可能的算术溢出。如果无法正确计算所请求的块大小，将导致分配失败（空指针）。同时，您的malloc版本不会尝试监视溢出。如果发生溢出，它将分配一些“不可预测的”内存。

摘自Georg Hager博客上用calloc（）和零页进行基准测试的乐趣

使用calloc（）分配内存时，请求的内存量不会立即分配。取而代之的是，某些MMU魔术将属于该内存块的所有页面连接到包含全零的单个页面（下面的链接）。如果仅读取此类页面（在基准的原始版本中，数组b，c和d确实如此），则从单个零页面提供数据，这当然适合缓存。对于绑定内存的循环内核来说就这么多。如果页面被写入（无论如何），都会发生错误，“实际”页面将被映射，零页面将被复制到内存中。这称为写时复制，这是一种众所周知的优化方法（我什至在我的C ++讲座中都曾多次教过它）。之后，

calloc一般malloc+memset为0

通常最好malloc+memset显式使用，特别是在执行以下操作时：

ptr=malloc(sizeof(Item));
memset(ptr, 0, sizeof(Item));

这样比较好，因为sizeof(Item)编译器在编译时就知道了，并且在大多数情况下，编译器将使用最佳的零内存指令来替换它。另一方面，如果memset在中发生calloc，则分配的参数大小不会在calloc代码中编译memset，而通常会调用real ，这通常会包含代码来逐字节填充直到长边界，而不是循环填充sizeof(long)逐块存储，最后逐字节填充剩余空间。即使分配器足够聪明，可以调用某些分配器，aligned_memset它仍将是一个通用循环。

一个值得注意的例外是，当您对非常大的内存块（某些power_of_两千字节）执行malloc / calloc时，这种情况下可以直接从内核完成分配。由于操作系统内核通常会出于安全原因将它们释放的所有内存清零，因此足够聪明的calloc可能会在没有额外清零的情况下将其返回。再说一次-如果您只是分配一些您知道的很小的东西，那么在性能方面使用malloc + memset可能会更好。

差异1：

malloc() 通常分配内存块，并初始化内存段。

calloc() 分配内存块并将所有内存块初始化为0。

差异2：

如果考虑malloc()语法，则仅需要1个参数。考虑下面的示例：

data_type ptr = (cast_type *)malloc( sizeof(data_type)*no_of_blocks );

例如：如果您要为int类型分配10个内存块，

int *ptr = (int *) malloc(sizeof(int) * 10 );

如果考虑calloc()语法，则将使用2个参数。考虑下面的示例：

data_type ptr = (cast_type *)calloc(no_of_blocks, (sizeof(data_type)));

例如：如果您要为int类型分配10个内存块，并将所有内存初始化为ZERO，

int *ptr = (int *) calloc(10, (sizeof(int)));

相似：

双方malloc()并calloc()会默认返回void *，如果他们不是类型铸造！

有两个区别。
首先，是参数的数量。malloc()需要一个参数（以字节为单位的内存），而calloc()需要两个参数。
其次，malloc()不初始化分配的内存，而calloc()将分配的内存初始化为零。

• calloc()分配一个内存区域，长度将为其参数的乘积。calloc用零填充内存，并返回指向第一个字节的指针。如果找不到足够的空间，它将返回一个NULL指针。

语法：ptr_var=(cast_type *)calloc(no_of_blocks , size_of_each_block); ieptr_var=(type *)calloc(n,s);

• malloc()分配REQUSTED SIZE的单个内存块，并返回指向第一个字节的指针。如果找不到所需的内存量，它将返回空指针。

语法：ptr_var=(cast_type *)malloc(Size_in_bytes); 该malloc()函数取一个参数，它是字节数来分配，而calloc()函数有两个参数，其中之一是元件的数量，而另一个是字节数分配为每个元件。同样，calloc()将分配的空间初始化为零，而malloc()不会初始化为零。

该calloc()是在声明的函数<stdlib.h>头提供了几个优点，在malloc()功能。

1. 它将内存分配为给定大小的多个元素，并且
2. 它初始化分配的内存，以便所有位均为零。

malloc()并且calloc()是从C标准库，允许动态存储器分配的，这意味着它们都允许在运行时内存分配函数。

他们的原型如下：

void *malloc( size_t n);
void *calloc( size_t n, size_t t)

两者之间主要有两个区别：

• 行为：malloc()分配一个内存块而不进行初始化，并且从该块中读取内容将导致垃圾值。calloc()另一方面，分配一个内存块并将其初始化为零，显然读取该块的内容将导致零。

• 语法：malloc()接受1个参数（要分配的大小），calloc()接受两个参数（要分配的块数和每个块的大小）。

如果成功，两者的返回值都是指向分配的内存块的指针。否则，将返回NULL，指示内存分配失败。

例：

int *arr;

// allocate memory for 10 integers with garbage values
arr = (int *)malloc(10 * sizeof(int)); 

// allocate memory for 10 integers and sets all of them to 0
arr = (int *)calloc(10, sizeof(int));

calloc()使用malloc()和可以实现相同的功能memset()：

// allocate memory for 10 integers with garbage values   
arr= (int *)malloc(10 * sizeof(int));
// set all of them to 0
memset(arr, 0, 10 * sizeof(int)); 

请注意，malloc()最好使用calloc()它，因为它更快。如果需要零值初始化，请calloc()改用。

尚未提及的差异：大小限制

void *malloc(size_t size)最多只能分配SIZE_MAX。

void *calloc(size_t nmemb, size_t size);可以分配约SIZE_MAX*SIZE_MAX。

在具有线性寻址功能的许多平台中，通常不使用此功能。这样的系统限制calloc()了nmemb * size <= SIZE_MAX。

考虑一种称为512字节的类型，disk_sector代码想要使用很多扇区。在这里，代码最多只能使用SIZE_MAX/sizeof disk_sector扇区。

size_t count = SIZE_MAX/sizeof disk_sector;
disk_sector *p = malloc(count * sizeof *p);

考虑以下允许更大分配的情况。

size_t count = something_in_the_range(SIZE_MAX/sizeof disk_sector + 1, SIZE_MAX)
disk_sector *p = calloc(count, sizeof *p);

现在，如果这样的系统可以提供这么大的分配，那就另当别论了。今天大多数时候不会。但是它已经发生了很多年，当时SIZE_MAX是65535。考虑到摩尔定律，怀疑这种情况将在2030年左右发生，某些内存模型的SIZE_MAX == 4294967295内存池为100 GB。

块数：
malloc（）分配所请求内存的单个块，
calloc（）分配所请求内存的多个块

初始化：
malloc（）-不清除并初始化分配的内存。
calloc（）-将分配的内存初始化为零。

速度：
malloc（）很快。
calloc（）比malloc（）慢。

参数和语法：
malloc（）接受1个参数：

1. 个字节

   • 要分配的字节数

calloc（）接受2个参数：

1. 长度

   • 要分配的内存块数
2. 个字节
   • 每个内存块分配的字节数

void *malloc(size_t bytes);         
void *calloc(size_t length, size_t bytes);      

内存分配方式：
malloc函数从可用堆中分配所需“大小”的内存。
calloc函数分配的内存等于'num * size'的大小。

名称上的含义：
名称malloc表示“内存分配”。
名称calloc表示“连续分配”。