malloc和calloc区别

C语言动态内存分配与释放C语言作为一门广泛应用的编程语言，具有良好的灵活性和高效性。

在C语言中，动态内存分配与释放是一项重要的特性，它可以在程序运行过程中根据需要动态分配内存，并在使用完毕后释放，避免内存浪费和内存泄漏的问题。

本文将深入探讨C语言中的动态内存分配与释放的相关知识。

1. 动态内存分配概述在C语言中，使用静态内存分配的方式会提前将内存分配给变量，这在一些情况下会导致内存的浪费。

为了更加高效地利用内存，C语言提供了动态内存分配的机制。

动态内存分配允许我们在程序运行时根据需要动态地分配内存空间给变量或数据结构，并且在不再需要的时候释放这些内存空间。

2. 动态内存分配函数C语言提供了几个常用的动态内存分配函数，包括malloc、calloc、realloc和free。

- malloc函数：用于在堆中分配指定大小的内存空间，并返回指向该空间起始地址的指针。

- calloc函数：用于在堆中分配指定数量和大小的内存空间，并将内存空间初始化为0。

- realloc函数：用于调整已分配内存空间的大小，可以扩大或缩小内存空间。

- free函数：用于释放之前通过动态内存分配函数分配的内存空间。

3. 动态内存分配的示例下面是一个示例代码，演示了如何使用动态内存分配函数来分配内存空间，并在使用完毕后释放内存空间。

```c#include <stdio.h>#include <stdlib.h>int main() {int n;printf("请输入元素个数：");scanf("%d", &n);int* arr = (int*)malloc(n * sizeof(int)); // 使用malloc函数动态分配n个int型变量所占的内存空间if (arr == NULL) {printf("内存分配失败！");return 1; // 内存分配失败，退出程序}for (int i = 0; i < n; i++) {printf("请输入第%d个元素的值：", i + 1);scanf("%d", &arr[i]);}printf("输入的元素为：");for (int i = 0; i < n; i++) {printf("%d ", arr[i]);}free(arr); // 释放动态分配的内存空间return 0;}```在上述示例中，我们通过malloc函数动态分配了一个整型数组的内存空间，并在使用完毕后使用free函数将其释放，以避免内存泄漏。

这一行，作用完全等同于：
int* p = (int *)malloc(sizeof(int) * 10);
（5）关于alloca()函数
还有一个函数也值得一提，这就是alloca()。其调用序列与malloc相同，但是它是在当前函数的栈帧上分配存储空间，而不是在堆中。其优点是：当 函数返回时，自动释放它所使用的栈帧，所以不必再为释放空间而费心。其缺点是：某些系统在函数已被调用后不能增加栈帧长度，于是也就不能支持alloca 函数。尽管如此，很多软件包还是使用alloca函数，也有很多系统支持它。
（3）calloc函数的分配的内存也需要自行释放
calloc函数的功能与malloc函数的功能相似，都是从堆分配内存,它与malloc函数的一个显著不同时是，calloc函数得到的内存空间是经过初始化的，其内容全为0。calloc函数适合为数组申请空间，可以将size设置为数组元素的空间长度，将n设置为数组的容量。
（2）使用malloc函数分配的堆空间在程序结束之前必须释放
从堆上获得的内存空间在程序结束以后，系统不会将其自动释放，需要程序员来自己管理。一个程序结束时，必须保证所有从堆上获得的内存空间已被安全释放，否则，会导致内存泄露。
我们可以使用free()函数来释放内存空间，但是，free函数只是释放指针指向的内容，而该指针仍然指向原来指向的地方，此时，指针为野指针，如果此时操作该指针会导致不可预期的错误。安全做法是：在使用free函数释放指针指向的空间之后，将指针的值置为NULL。
所以，在代码中，我们必须将realloc返回的值，重新赋值给 p :
p = (int *) realloc(p, sizeof(int) *15);
甚至，你可以传一个空指针（0）给 realloc ，则此时realloc 作用完全相当于malloc。

C语言常用数学函数1.数学函数：如sqrt、sin、cos、tan、exp、log等，可用于处理数学运算。

比如：x表示需要计算平方根的数值。

sqrt函数会返回x的正平方根，如果x是负数，则返回NaN（Not a Number）。

exp用于计算一个数的自然指数值（以e为底的指数）。

log函数返回x的自然对数，即ln(x)。

Doubl esqrt(doublex);2.字符串函数：如strcpy、strncpy、strcat、strcmp、strlen等，用于处理字符串。

strcpy用于将一个字符串复制到另一个字符串中。

dest表示目标字符串的起始地址，src表示源字符串的起始地址。

当使用strcpy函数进行字符串复制时，必须确保目标字符串空间足够大，否则可能会导致内存访问越界等问题。

char*strcpy(char*dest,constchar*src);strncpy用于将一个字符串的部分内容复制到另一个字符串中。

，n表示需要复制的字符个数。

如果源字符串长度小于n，则目标字符串将被填充一些空字符直到长度为n。

char*strncpy(char*dest,constchar*src,size_tn);strcat用于将一个字符串连接到另一个字符串的末尾。

strcmp用于比较两个字符串的大小关系。

strlen用于计算一个字符串的长度（即包含多少个字符）。

注意的是，strlen函数不会计算空字符'\0'的长度。

3.文件操作函数：如fopen、fclose、fread、fwrite、fgets 等，可用于文件的读取和写入。

4.内存函数：如malloc、calloc、realloc、free等，用于动态内存分配和释放。

malloc用于动态分配内存空间。

free用于释放动态分配的内存空间。

5.格式化函数：如printf、scanf、sprintf、sscanf等，用于输入输出和格式化字符串。

calloc函数和malloccalloc和malloc都是C语言中分配内存的函数，它们有一些共同点和不同点。

共同点：1. 两个函数都是用来分配内存的，返回一个void *类型的指针，可以用来操作新分配的内存。

2. 分配的内存长度由用户指定，可以是任何整数。

3. 如果分配的内存不被使用了，可以使用free函数将其释放。

1. 分配的方式不同。

malloc函数只分配内存空间，但不初始化分配的内存区域。

而calloc函数分配的内存空间会被初始化为0。

2. 分配的参数不同。

malloc只接受一个参数来指定需要分配的空间大小，而calloc 函数需要两个参数，第一个参数是需要分配的连续内存区域个数，第二个参数是每个内存区域的大小。

3. 分配的效率不同。

calloc相比malloc可能会更慢一些，因为它需要初始化分配的内存区域，而malloc不需要这样做。

下面分别介绍一下这两个函数的用法：1. mallocmalloc用于分配内存，原型如下：void *malloc(size_t size);其中size_t是无符号整型变量，用来表示要分配的内存大小。

使用示例：```int *p = (int *)malloc(sizeof(int));if(p == NULL){printf("分配内存失败。

\n");}else{*p = 123;printf("*p = %d\n", *p);free(p);}```这段代码先分配了一个int类型的变量所需的内存空间，然后将分配的地址赋值给指针p。

如果分配失败，则p将被赋值为NULL；如果分配成功，则可以通过指针p来操作新分配的内存。

最后，使用free函数释放分配的内存。

其中num是需要分配的连续内存区域个数，size是每个内存区域的大小。

总结：calloc和malloc在分配内存时具有不同的作用。

calloc分配的空间会被初始化为0，而malloc分配的空间不做初始化。

函数简介原型：extern void *malloc(unsigned int num_bytes);头文件：在TC2.0中可以用malloc.h或 alloc.h (注意：alloc.h 与malloc.h 的内容是完全一致的)，而在Visual C++6.0中可以用malloc.h或者stdlib.h。

功能：分配长度为num_bytes字节的内存块返回值：如果分配成功则返回指向被分配内存的指针，否则返回空指针NULL。

当内存不再使用时，应使用free()函数将内存块释放。

说明：关于该函数的原型，在旧的版本中malloc返回的是char型指针，新的ANSIC标准规定，该函数返回为void型指针，因此必要时要进行类型转换。

名称解释：malloc的全称是memory allocation，中文叫动态内存分配。

相关函数：calloc、realloc、free、_alloca函数声明void *malloc(int size);说明：malloc 向系统申请分配指定size个字节的内存空间。

返回类型是void* 类型。

void* 表示未确定类型的指针。

C,C++规定，void* 类型可以强制转换为任何其它类型的指针。

从函数声明上可以看出。

malloc 和 new 至少有两个不同: new 返回指定类型的指针，并且可以自动计算所需要大小。

比如：int *p;p = new int; //返回类型为int* 类型(整数型指针)，分配大小为sizeof(int);或：int* parr;parr = new int [100]; //返回类型为 int* 类型(整数型指针)，分配大小为 sizeof(int) * 100;而 malloc 则必须由我们计算要字节数，并且在返回后强行转换为实际类型的指针。

int* p;p = (int *) malloc (sizeof(int));第一、malloc 函数返回的是 void * 类型。

cc++动态申请数组new和delete运算符⽤于动态分配和撤销内存的运算符new使⽤⽅法:1. 开辟单变量地址空间1)new int; //开辟⼀个存放数组的存储空间,返回⼀个指向该存储空间的地址.int *a = new int 即为将⼀个int类型的地址赋值给整型指针a.2)int *a = new int(5) 作⽤同上,可是同⼀时候将整数赋值为52. 开辟数组空间⼀维: int *a = new int[100];开辟⼀个⼤⼩为100的整型数组空间⼆维: int **a = new int[5][6]三维及其以上:依此类推.⼀般使⽤⽅法: new 类型 [初值]delete使⽤⽅法:1. int *a = new int;delete a; //释放单个int的空间2.int *a = new int[5];delete [] a; //释放int数组空间要訪问new所开辟的结构体空间,⽆法直接通过变量名进⾏,仅仅能通过赋值的指针进⾏訪问.⽤new和delete能够动态开辟,撤销地址空间.在编程序时,若⽤完⼀个变量(通常是临时存储的数组),下次须要再⽤,但却⼜想省去⼜⼀次初始化的功夫,能够在每次開始使⽤时开辟⼀个空间,在⽤完后撤销它.#include <iostream>using namespace std;int main(){char *p=new char[10];scanf ("%s",p);printf ("%s",p);delete []p;while (1);return 0;}这是⼆维数组的申请⽅法#define ROW 100#define COL 200#define T char (int,float,....) //通⽤数据类型T ** pTemp ;*pTemp = new T[ROW] ;for (int i = 0 ; i < COL ; i ++)pTemp[i] = new T[COL};/////////////////deletefor (int i =0 ; i < COL ; i ++)delete [] pTemp[i] ;delete [][]pTemp ;1.分配内存空间函数malloc 调⽤形式： (类型说明符*) malloc (size) 功能：在内存的动态存储区中分配⼀块长度为"size" 字节的连续区域。

calloc和malloc的用法calloc和malloc都是C语言中动态内存分配函数，用于在程序运行时动态分配内存。

1. malloc函数：malloc函数的原型为：void* malloc(size_t size);参数size表示需要分配的内存大小（以字节为单位）。

调用malloc函数分配内存时，会从堆中找到合适大小的连续内存块分配给程序，并返回分配的内存地址。

注意：malloc只负责分配内存，并不对分配的内存进行初始化，所以分配的内存中的值是未知的。

2. calloc函数：calloc函数的原型为：void* calloc(size_t num, size_t size);参数num表示需要分配的元素个数，而参数size表示每个元素的大小（以字节为单位）。

调用calloc函数时，会分配一个大小为num*size的内存块，并将该内存块中的每个字节都初始化为0。

和malloc函数不同的是，calloc函数分配的内存连续块中的值都是0。

使用malloc和calloc的一般步骤：1. 声明一个指针变量，用于存储分配的内存地址。

2. 调用malloc或calloc函数，传入需要分配的内存大小或元素个数以及每个元素的大小。

3. 检查函数返回的指针是否为NULL，如果为NULL则说明分配失败，可能是由于内存不足。

4. 使用分配的内存进行各种操作。

5. 在不需要使用分配的内存时，使用free函数将其释放，防止内存泄漏。

示例：```c#include <stdio.h>#include <stdlib.h>int main() {int* arr = (int*)calloc(5, sizeof(int));if (arr != NULL) {for (int i = 0; i < 5; i++) {printf("%d ", arr[i]); // 输出0}printf("\n");free(arr);}return 0;}```以上示例代码中，通过调用calloc函数分配了一个包含5个整数的内存块，并将其每个字节都初始化为0。

memme函数
memme函数是一种内存管理函数，用于在程序中动态分配和释放内存。

它在 C 语言中被广泛使用，可以帮助程序员避免在运行时出
现内存溢出和泄漏的问题。

memme函数包括四个主要函数：malloc、calloc、realloc 和 free。

其中，malloc用于分配指定大小的内存空间；calloc用于分配指定
数量和大小的连续空间；realloc用于重新调整先前分配的内存空间大小；free用于释放先前分配的内存空间。

这些函数对于程序员来说非常重要，因为内存管理是编写高效程序的关键部分。

如果程序员不妥善管理内存，程序可能会出现意想不到的崩溃和错误。

因此，memme函数是编写高质量 C 程序的必备工
具之一。

- 1 -。

C语言分配内存并赋值的函数1. 概述在C语言中，我们经常需要动态地分配内存来存储数据。

为了方便地进行内存分配和赋值操作，C语言提供了一些特定的函数。

这些函数可以帮助我们在程序运行时动态地分配内存，并将指定的值赋给所分配的内存空间。

本文将详细介绍C语言中的几个常用的分配内存并赋值的函数，包括malloc、calloc和realloc。

我们将分别介绍它们的定义、用途和工作方式，并给出一些示例代码来说明它们的使用方法。

2. malloc函数2.1 定义malloc函数是C语言中用于动态分配内存的函数。

它的原型定义在stdlib.h头文件中，其定义如下：void* malloc(size_t size);2.2 用途malloc函数用于在程序运行时动态地分配指定大小的内存空间。

这个函数返回一个指向分配内存的指针，如果分配失败则返回NULL。

2.3 工作方式malloc函数的工作方式如下：1.接收一个size_t类型的参数size，表示需要分配的内存空间的大小。

2.在堆（heap）中分配一块大小为size的连续内存空间。

3.返回指向分配内存的指针，如果分配失败则返回NULL。

2.4 示例代码下面是一个使用malloc函数分配内存并赋值的示例代码：#include <stdio.h>#include <stdlib.h>int main() {int* ptr;int size = 5;ptr = (int*)malloc(size * sizeof(int));if (ptr == NULL) {printf("内存分配失败\n");return 1;}for (int i = 0; i < size; i++) {ptr[i] = i + 1;}for (int i = 0; i < size; i++) {printf("%d ", ptr[i]);}free(ptr);return 0;}上述代码中，我们使用malloc函数分配了一块大小为 5 * sizeof(int)的内存空间，并将其地址赋给指针ptr。

C语言是一种广泛使用的编程语言，它提供了许多功能和工具，但同时也存在一些可能导致内存越界的问题。

下面是一些可能导致内存越界的函数，以及它们的原因和可能的解决方案：1. 字符串拷贝函数（strcpy）strcpy函数用于将一个字符串复制到另一个字符串中。

如果传递给strcpy函数的源字符串的长度超过了目标字符串的大小，就会导致内存越界。

例如，如果源字符串长度为100字节，而目标字符串的大小只有80字节，那么就会覆盖后面的内存空间，从而导致内存越界。

解决方案：在使用strcpy函数时，应该确保源字符串的长度不超过目标字符串的大小。

可以使用strlen函数来获取源字符串的长度，并确保目标字符串有足够的空间来容纳源字符串。

2. 动态内存分配函数（malloc、calloc、realloc）这些函数用于在堆上分配内存。

如果调用这些函数时传递了错误的参数（例如，传递了一个负数作为大小参数），或者在释放内存之前就调用了这些函数，就可能导致内存越界。

解决方案：在使用这些函数时，应该确保传递正确的参数大小，并确保在使用完内存后释放它。

可以使用free函数来释放分配的内存，以避免内存泄漏。

3. 文件操作函数（fopen、fclose、fread、fwrite）这些函数用于文件操作，可能会导致内存越界的问题。

例如，如果打开的文件超过了可用内存的大小，或者读取的数据超过了缓冲区的大小，就可能导致内存越界。

解决方案：在使用这些函数时，应该确保文件大小不会超过可用内存的大小，并确保读取的数据不会超过缓冲区的大小。

可以使用fseek、fread等函数来控制文件的位置和大小。

总之，为了避免内存越界的问题，应该仔细检查函数的参数和返回值，确保它们符合预期的边界条件。

此外，还应该使用适当的错误处理机制来处理可能出现的异常情况。

结构体与共用体笔记定义结构体C语言允许用户自己建立由不同类型数据组成的组合型的数据结构，它称为结构体(structre)。

在其他一些高级语言中称为“记录”.定义后的结构体类型和系统提供的标准类型(如int, char, float, double 等)具有相似的作用，都可以用来定义变量，只不过int等类型是系统已声明的，而结构体类型是由用户根据需要在程序中指定的。

定义一个结构体类型的一般形式为：struct 结构体名{ 成员表列}；注意：1.结构体类型的名字是由一个关键字struct和结构体名组合而成的(例如struct Student) ，结构体名是由用户指定的，又称“结构体标记”，以区别于其他结构体类型。

上面的结构体声明中Student就是结构体名(结构体标记)。

2.花括号内是该结构体所包括的子项，称为结构体的成员。

“成员表列"(member list)也称为“域表”(field list),成员表列由若干个成员组成,每一个成员是结构体中的一个域。

对每个成员也必须作类型说明，其形式为：类型说明符成员名;成员名的命名应符合标识符的书写规定。

例如：struct stu{int num;char name[20];char sex;float score;};3.一个结构体的成员可以属于另一个结构体类型（嵌套）。

例如：struct Date //声明一个结构体类型struct Date{ int month;//月int day;//日int year；//年}struct Student//声明一个结构体类型struct Student{ int num；char name[20]；char sex；int age;struct Date birthday;//成员birthday属于struct Date 类型char addr[30]；};结构体类型变量1.定义结构体类型变量说明结构变量有以下三种方法。

calloc函数和malloc
在C语言中，动态内存分配对于程序员来说是非常重要的。

malloc和calloc是两个常用的动态内存分配函数。

malloc函数用于在内存中分配一块指定大小的连续空间，并返回分配的内存的地址，以便我们可以在程序中使用它。

例如，以下代码分配了一块大小为10个整数的内存：
int *p = (int*) malloc(10 * sizeof(int));
calloc函数也用于在内存中分配一块指定大小的连续空间，但是它有一个额外的参数：初始化为0。

它接受两个参数：所需的元素数和元素大小。

例如，以下代码分配了一块大小为10个整数的内存并将它们初始化为0：
int *p = (int*) calloc(10, sizeof(int));
因此，calloc和malloc在内存分配方面非常相似，但是它们的行为略有不同。

最重要的区别是：calloc在分配内存时将其设置为0。

这是malloc无法保证的。

另一个区别是：calloc需要更多的时间来执行，因为它不仅分配内存，而且还必须将所有字节设置为0。

在大多数情况下，性能差异不会很大，但是如果您需要分配大量内存，这可能会成为一个问题。

在实践中，选择calloc或malloc通常取决于您的程序的具体需求。

如果您需要分配一些内存，但不需要将其设置为0，则应使用malloc。

如果您需要分配一些内存，并且要将其设置为0，则应使用
calloc。

c中malloc的用法下面就跟你们详细介绍下c中malloc的用法的用法，希望对你们有用。

c中malloc的用法的用法如下：函数声明(函数原型)：void *malloc(int size);说明：malloc 向系统申请分配指定size个字节的内存空间。

返回类型是void* 类型。

void* 表示未确定类型的指针。

C,C++规定，void* 类型可以强制转换为任何其它类型的指针。

从函数声明上可以看出。

malloc 和new 至少有两个不同: new 返回指定类型的指针，并且可以自动计算所需要大小。

比如：int *p;p = new int; //返回类型为int* 类型(整数型指针)，分配大小为sizeof(int);或：int* parr;parr = new int [100]; //返回类型为int* 类型(整数型指针)，分配大小为sizeof(int) * 100;而malloc 则必须由我们计算要字节数，并且在返回后强行转换为实际类型的指针。

int* p;p = (int *) malloc (sizeof(int));第一、malloc 函数返回的是void * 类型，如果你写成：p = malloc (sizeof(int)); 则程序无法通过编译，报错：“不能将void* 赋值给int * 类型变量”。

所以必须通过(int *) 来将强制转换。

第二、函数的实参为sizeof(int) ，用于指明一个整型数据需要的大小。

如果你写成：int* p = (int *) malloc (1);代码也能通过编译，但事实上只分配了1个字节大小的内存空间，当你往里头存入一个整数，就会有3个字节无家可归，而直接“住进邻居家”！造成的结果是后面的内存中原有数据内容全部被清空。

malloc 也可以达到new [] 的效果，申请出一段连续的内存，方法无非是指定你所需要内存大小。

比如想分配100个int类型的空间：int* p = (int *) malloc ( sizeof(int) * 100 ); //分配可以放得下100个整数的内存空间。

在C语言中，内存的申请和释放需要使用动态内存分配函数和析构函数。

1. 内存申请：使用动态内存分配函数malloc()或calloc()可以申请一定大小的内存空间。

malloc()函数用于申请单块内存，而calloc()函数用于申请多块内存。

malloc()函数的语法如下：void* malloc(size_t size);其中，size表示需要申请的内存空间大小，返回值为指向申请到的内存空间的指针。

calloc()函数的语法如下：void* calloc(size_t num, size_t size);其中，num表示需要申请的内存空间数量，size表示每个内存空间的大小，返回值为指向申请到的内存空间的指针。

2. 内存释放：使用free()函数可以释放动态申请的内存空间。

free()函数的语法如下：void free(void* ptr);其中，ptr表示需要释放的内存空间指针。

在释放内存之前，需要先检查申请到的内存空间是否已经被释放，否则会导致内存泄漏。

3. 使用智能指针在C++中，可以使用智能指针来管理动态分配的内存空间。

智能指针可以自动释放内存空间，避免了内存泄漏的问题。

智能指针的语法如下：#include <memory>std::unique_ptr<T> make_unique(T* ptr);std::shared_ptr<T> make_shared(T* ptr);std::weak_ptr<T> make_weak(T* ptr);其中，T表示需要管理的对象类型。

make_unique()和make_shared()函数分别用于创建unique_ptr和shared_ptr类型的智能指针，make_weak()函数用于创建weak_ptr类型的智能指针。

使用智能指针的优点在于，可以避免手动管理内存空间的问题，同时也可以避免内存泄漏的问题。

malloc和calloc的用法(中英文版)Title: malloc and calloc UsageIn C programming, dynamic memory allocation is essential for various operations, and two commonly used functions for this purpose are malloc() and calloc().在C编程中，动态内存分配对于各种操作至关重要，用于此目的的两个常用函数是malloc()和calloc()。

Both functions are used to allocate a block of memory of a specified size.However, there are some differences between them.这两个函数都用于分配一个指定大小的内存块。

然而，它们之间有一些区别。

malloc() stands for "memory allocation".It allocates a block of memory of the specified size and returns a pointer to the beginning of the block.The memory allocated by malloc() is not initialized, meaning the values in the memory block are undefined.malloc()代表“内存分配”。

它分配一个指定大小的内存块，并返回该块的起始地址的指针。

malloc()分配的内存不是初始化的，这意味着内存块中的值是未定义的。

On the other hand, calloc() stands for "contiguous allocation".It also allocates a block of memory of the specified size but returns a pointer to the beginning of the block.The difference is that the memory allocated by calloc() is initialized to zero.另一方面，calloc()代表“连续分配”。

C语言笔试题_C笔试题大全14_附答案c语言常见笔试题总结【1 使用宏】1.1 #error的作用？#error用于向编译器报错，并输出它后面带的错误信息。

例如：#ifndef SOMETHING#error SOMETHING not defined!#endif如果在这段代码之前未定义过SOMETHING，则在编译时出错，并给出"SOMETHING not defined!"的错误信息。

1.2 定义一个宏，求出给定数组中的元素的个数#define NELEMENTS(array) (sizeof(array) / sizeof((array)[0])) 【2 数据声明和定义】给定以下类型的变量a的定义式：a) An integerint a;b) A pointer to an integerint *a;c) A pointer to a pointer to an integerint **a;d) An array of 10 integersint a[10];e) An array of 10 pointers to integersint *a[10];f) A pointer to an array of 10 integersint (*a)[10];g) A pointer to a function that takes an integer as an argument and returns an integerint (*a)(int );h) An array of ten pointers to function s that take an integer argument and return an integeri nt (*a[10] ) (int );【3 复杂类型（1）】有如下表达式：char (*(*x())[])();请用文字描述x是什么。

【malloc和calloc】malloc和calloc函数区别malloc和calloc函数在参数个数、初始化内存空间、函数返回值上有区别：1、参数个数上的区别：malloc函数：malloc( size)函数有⼀个参数，即要分配的内存空间的⼤⼩。

calloc函数：calloc( numElements, sizeOfElement)有两个参数，分别为元素的数⽬和每个元素的⼤⼩，这两个参数的乘积就是要分配的内存空间的⼤⼩。

2、初始化内存空间上的区别：malloc函数：不能初始化所分配的内存空间，在动态分配完内存后，⾥边数据是随机的垃圾数据。

calloc函数：能初始化所分配的内存空间，在动态分配完内存后，⾃动初始化该内存空间为零。

malloc与calloc没有本质区别，malloc之后的未初始化内存可以使⽤memset进⾏初始化。

1. 主要的不同是malloc不初始化分配的内存，calloc初始化已分配的内存为0。

2. 次要的不同是calloc返回的是⼀个数组，⽽malloc返回的是⼀个对象。

3. calloc等于malloc后在memset很可能calloc内部就是⼀个malloc再来⼀个memset清0。

4. 所以malloc⽐calloc更⾼效。

5. 分配内存空间函数malloc 调⽤形式: (类型说明符*) malloc (size) 。

6. 分配内存空间函数 calloc calloc 也⽤于分配内存空间。

为什么多⽤malloc⽽很少⽤calloc？因为calloc虽然对内存进⾏了初始化（全部初始化为0），但是同样也要降低效率的calloc相当于p = malloc();memset(p, 0,size);多了对内存的写零操作，⽽写零这个操作我们有时候需要，⽽⼤部分时间不需要扩展资料：malloc()在内存中的⼯作机制：malloc函数的实质体现在，它有⼀个将可⽤的内存块连接为⼀个长长的列表的所谓空闲链表。