动态内存分配函数

dynamic在c语言中的意思
dynamic在c语言中通常指动态内存分配，也称为堆内存分配。

它与静态内存分配相对，静态内存分配是在编译时确定内存分配的大小和位置，在程序运行时不会改变。

而动态内存分配则是在程序运行时根据需要动态分配内存空间，可以根据程序的实际需求进行调整。

使用动态内存分配可以避免内存浪费，提高程序的灵活性和效率。

在c语言中，常用的动态内存分配函数有malloc、calloc和realloc。

需要注意的是，在动态内存分配使用完毕后，必须及时进行内存释放，否则会造成内存泄露，导致程序运行缓慢或崩溃。

- 1 -。

c语言calloc函数用法
calloc函数是C语言用于内存分配的动态内存分配函数，是malloc函数的延伸，它能够分配一定大小内存，主要用于创建动态数组。

一、calloc函数的定义
calloc函数是内存分配函数，函数原型为void *calloc(size_t num, size_t size);其
中第一个参数num指定了使用多少个内存，第二个参数size指定每个内存单元的
大小，calloc会把大小为num × size的内存分配出来，并且初始化每一个内存单元
为0，最后返回指向这块分配内存的指针。

二、calloc函数的使用实例
1.首先我们需要包含头文件stdlib.h，以使用calloc函数；
2.定义一个指针指向分配的内存的指针p，以便存放calloc函数返回的指针，例如： int *p=NULL；
3.调用calloc函数：
p=(int *)calloc(5,sizeof(int))，用calloc函数分配了5个int大小的内存；
4.令每一个分配的内存的赋值，例如：
for(i=0;i<5;i++)
{
p[i]=i*2;
}
三、calloc函数的优缺点
1.优点：
（1）calloc函数可以实现动态内存分配，降低了内存分配的难度。

（2）calloc函数可以实现自动初始化，减少初始化操作。

2.缺点：
（1）calloc函数的效率较malloc函数稍低。

（2）由于calloc函数实现的自动初始化，会造成内存的浪费。

fortran allocate函数首先，需要了解Fortran编程语言中的allocate函数。

在Fortran中，allocate函数用于动态分配内存空间，以便在编程过程中创建数组或数据结构。

在Fortran编程中，静态分配是指在程序启动时为变量分配固定大小的内存空间，而动态分配则是在运行时根据需要分配内存空间。

allocate函数允许程序员根据需要分配内存空间，从而更加灵活地使用计算资源。

接下来，我们将逐步讨论allocate函数的用法和功能。

步骤1：理解allocate函数的语法allocate函数的语法如下：allocate (variable [, source])其中，variable是要分配内存空间的变量名称，source是可选的，用于指定分配内存的源变量。

步骤2：为变量分配内存空间要使用allocate函数为变量分配内存空间，需要在程序中声明变量，并在需要的位置使用allocate函数进行分配。

例如，假设我们想要在Fortran 程序中使用一个长度为n的数组，可以如下声明和分配内存空间：! 声明变量integer, allocatable :: array(:)! 分配内存空间allocate(array(n))上述代码首先声明了一个整数类型的allocatable数组array，然后使用allocate函数为数组分配了长度为n的内存空间。

步骤3：使用allocate函数释放内存空间在使用allocate函数分配内存空间后，我们还必须确保在使用完分配的内存后释放它，以避免内存泄漏。

可以使用deallocate函数来释放内存空间。

例如，我们可以在不再需要数组array时使用deallocate函数释放其内存空间：! 释放内存空间deallocate(array)使用deallocate函数后，将对array变量原有的内存空间进行释放。

步骤4：动态调整内存空间大小allocate函数的一个重要功能是允许动态调整内存空间的大小。

c语言动态分配的用法C语言中，动态内存分配是通过使用malloc、calloc和realloc等函数来实现的。

动态分配内存可以根据程序运行时的需要来动态分配和释放内存空间，提高程序的灵活性和效率。

1. malloc函数：用于在堆（heap）中分配指定大小的内存空间。

其函数原型为void* malloc(size_t size)，其中size为要分配的内存空间的大小（以字节为单位）。

例如，以下代码动态分配了一个包含5个整数的整型数组的内存空间，并将其地址赋给指针变量p：```cint* p = (int*)malloc(5 * sizeof(int));```2. calloc函数：用于在堆中分配指定数量和大小的连续内存空间，并将其初始化为零值。

其函数原型为void* calloc(size_t num,size_t size)，其中num为要分配的元素个数，size为每个元素的大小。

例如，以下代码动态分配了一个包含5个整数的整型数组的内存空间，并将其地址赋给指针变量p：```cint* p = (int*)calloc(5, sizeof(int));```3. realloc函数：用于重新分配已分配内存空间的大小。

其函数原型为void* realloc(void* ptr, size_t size)，其中ptr为指向已分配内存空间的指针，size为重新分配的内存空间的大小。

例如，以下代码将已分配内存空间的大小重新设置为10个整数，并将其地址赋给指针变量p：```cint* p = (int*)malloc(5 * sizeof(int));int* q = (int*)realloc(p, 10 * sizeof(int));if (q != NULL) {p = q;}```4. free函数：用于释放由malloc、calloc和realloc函数分配的内存空间。

其函数原型为void free(void* ptr)，其中ptr为指向要释放的内存空间的指针。

malloc内存分配流程在编程中，动态内存分配是一种常见的操作，而malloc()函数是用于在运行时分配内存的标准C库函数之一。

下面是malloc内存分配的流程。

1. 引入头文件：在使用malloc函数之前，需要在代码的开头引入头文件<cstdlib>或<stdlib.h>，以便使用malloc函数的定义和相关函数。

2. 了解malloc函数的作用：malloc函数用于在堆内存中动态分配指定字节数的内存空间，并返回一个指向分配内存开始位置的指针。

3. 为内存分配指定字节数：在调用malloc函数时，需要指定需要分配的内存空间的字节数，以便函数能够为该内存空间分配足够的大小。

例如，如果需要分配10个int类型的元素，可以使用sizeof(int) * 10来指定所需的字节数。

4. 检查分配是否成功：在调用malloc函数后，需要检查分配是否成功。

当分配成功时，malloc函数返回一个非空指针，该指针指向分配的内存空间的开始位置；当分配失败时，malloc函数返回一个空指针NULL。

5. 使用分配的内存空间：一旦分配成功，可以使用返回的指针来操作分配的内存空间。

例如，可以对分配的内存空间进行读写操作，存储数据或者访问已存储的数据。

6. 释放已分配的内存空间：在使用完分配的内存空间后，为了避免内存泄漏，应该使用free函数将其释放。

通过调用free函数，并将分配的指针作为参数传入，释放的内存将返回给系统，可以再次用于其他任务。

总结：将malloc内存分配的流程概括起来，首先引入头文件，然后了解malloc函数的作用，指定所需分配的字节数，检查分配是否成功，对分配的内存空间进行操作，最后使用free函数释放已分配的内存空间。

这个流程在动态内存分配中有着广泛的应用，能够帮助程序实现灵活的内存管理。

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。

remalloc函数的用法-回复【remalloc函数的用法】remalloc函数是在C语言中用于重新调整内存大小的函数。

它可以用于动态分配和重新分配内存空间。

本文将一步一步回答有关remalloc函数的用法，并深入探讨其功能和示例。

一、什么是remalloc函数？remalloc函数是在C语言中用于重新调整内存大小的函数。

它可以在已经分配了的内存上增加或减少分配的大小。

remalloc函数的原型为：void *remalloc(void *ptr, size_t size);参数ptr为一个指向已分配内存的指针，而size为希望重新调整的内存大小。

如果ptr为NULL，则remalloc函数会行为类似于malloc函数，即分配size大小的内存块。

如果ptr不为NULL，则remalloc函数会尝试将之前分配的内存块大小调整为size大小。

如果新分配的内存大小小于之前的大小，那么多余的部分将被丢弃。

如果新分配的内存大小大于之前的大小，那么额外的部分将未初始化。

需要注意的是，remalloc函数会将原来内存块中的数据复制到新的内存块中，并且返回一个指向新内存块的指针。

如果无法分配新的内存块，remalloc函数将返回NULL，并且原来的内存块不会被改变。

二、remalloc函数的示例以下是一个简单的示例，演示了remalloc函数的使用方法：#include <stdio.h>#include <stdlib.h>int main() {int* ptr;int i;ptr = (int*)malloc(5 * sizeof(int));if (ptr == NULL) {printf("Memory allocation failed!");return 1;}for (i = 0; i < 5; i++) {ptr[i] = i;printf("d ", ptr[i]);}printf("\n");ptr = (int*)realloc(ptr, 10 * sizeof(int)); if (ptr == NULL) {printf("Memory reallocation failed!"); return 1;}for (i = 5; i < 10; i++) {ptr[i] = i;printf("d ", ptr[i]);}free(ptr);return 0;在这个示例中，我们先分配了一个大小为5的int类型的内存块，并将其赋值为0、1、2、3、4。

c语言new的用法在C语言中，没有内置的new关键字用于动态分配内存。

C 语言中通常使用malloc()函数来动态分配内存，并使用free()函数来释放已分配的内存。

malloc()函数的用法：```#include <stdlib.h>// 分配n个字节的内存空间，并返回一个指向分配内存起始位置的指针void* malloc(size_t size);```malloc()函数使用size_t类型的参数指定要分配的字节数。

成功分配内存后，返回一个指向分配内存起始位置的指针。

如果分配失败，malloc()函数将返回NULL。

示例：```c#include <stdio.h>#include <stdlib.h>int main() {int* p = (int*)malloc(sizeof(int)); // 分配一个int类型的内存空间if (p != NULL) {*p = 10;printf("Value of p: %d\n", *p);free(p); // 释放内存}return 0;}```另外，可以使用calloc()函数来分配并初始化内存，与malloc()函数类似：```cvoid* calloc(size_t num, size_t size);```calloc()函数接受两个参数，分别是要分配内存的数量和每个元素的大小。

它会分配num个元素的内存，并将每个元素初始化为0。

示例：```c#include <stdio.h>#include <stdlib.h>int main() {int* arr = (int*)calloc(5, sizeof(int)); // 分配5个int类型的内存空间，并初始化为0if (arr != NULL) {for (int i = 0; i < 5; i++) {printf("Value at index %d: %d\n", i, arr[i]);}free(arr); // 释放内存}return 0;}```请注意，使用malloc()或calloc()分配的内存必须使用free()函数进行释放，以避免内存泄漏。

malloc原理malloc原理指的是内存动态分配的原理，是在程序执行过程中，通过动态地从内存中分配出指定大小的内存空间以供程序使用的过程。

比如实现对一维数组、二维数组、多维数组或者某个字符串等等，都可以通过malloc这样的函数来动态申请内存空间。

malloc是C语言中提供的一种内存管理功能，主要用于内存的动态分配。

在C语言程序中，malloc函数会从堆中申请一块内存空间，这块内存空间大小就是在定义函数时所传递的参数，返回指向该内存空间的指针。

malloc的原理很简单，首先，程序员需要指定需要申请的字节数，请求系统内存分配，系统会给出申请内存的指针。

简单来说，就是程序需要指定准备申请字节数，然后系统就会给出指向该字节数的指针，这样，程序就可以像对待一般数组一样，进行使用。

简而言之，malloc的实质就是提供了一块动态的内存空间。

malloc函数的实现原理也是非常简单的，以2的次方为基本单元，当申请的内存大小较小时，内存分配助手会从释放内存表中，挑选一块大小恰当的内存空间，然后分配给请求的程序；当内存申请大小较大时，会从系统空闲内存中申请，然后分配到申请的程序使用。

当程序结束malloc申请的内存使用后，可以通过free函数进行释放，free函数首先会检查指针是否指向由malloc函数申请的内存，如果是，则释放指针指向的内存，如果不是，则报错，提示程序出错。

malloc函数可以提供程序运行时即时、灵活、可定义大小的内存空间，因此在实际工作中，它是一个非常重要的函数，它可以满足程序运行时的大量需求。

malloc函数更多的用于存储有关指针的结构体、类、容器等数据，也就是把内存当做一个栈来管理内存空间，从而动态分配内存空间来达到需求所需。

总结一下，malloc原理指的是实现内存动态分配的原理，它的实质就是提供了一块可定义大小的动态内存空间，可以满足程序运行时的大量需求，malloc函数主要用于存储有关指针的结构体、类、容器等数据，将内存当做一个栈来管理空间，从而动态分配内存空间来实现需求所需。

zalloc函数zalloc函数是一个C语言标准库函数，用于动态分配内存空间。

它可以分配一个指定大小的内存块，并将其初始化为0。

在实际编程中，zalloc函数常用于初始化内存块时使用。

使用zalloc函数时需要包含头文件stdlib.h，函数原型为：```void *zalloc(size_t size);```参数size指定了需要分配的内存块的大小，单位为字节。

函数返回值为指向分配的内存块的指针。

如果分配失败，则返回NULL。

函数实现的基本思路是先通过malloc函数分配内存块，然后使用memset函数将内存块初始化为0。

示例代码如下：```#include <stdlib.h>#include <string.h>void *zalloc(size_t size){void *ptr = malloc(size);if (ptr != NULL) {memset(ptr, 0, size);}return ptr;}```使用zalloc函数时需要注意以下几点：1. 确定需要分配的内存块的大小；2. 检查返回值是否为NULL，以避免使用未分配的内存；3. 只有在需要初始化内存块时才使用zalloc函数，否则建议使用malloc函数分配内存块。

在实际编程中，zalloc函数的应用场景比较多，例如：1. 在嵌入式系统中，初始状态下所有的内存块通常是被清零的，因此可以使用zalloc函数分配和初始化内存块；2. 在文件操作中，为了避免读取到未初始化的内存，通常需要使用zalloc函数分配和初始化内存块；3. 在动态规划等算法中，需要使用大量的空间进行计算，因此通常会使用zalloc函数分配大块内存；4. 在网络编程中，需要分配和初始化大量的缓冲区，通常会使用zalloc函数。

zalloc函数是一个非常有用的函数，在实际编程中应用广泛。

除了常规的内存分配和初始化外，zalloc函数还有一些特殊的应用场景。

malloc 结构体指针数组在C语言中，我们经常需要使用结构体（struct）来组织和存储相关的数据。

而在某些情况下，我们可能需要动态地创建多个结构体对象，并使用指针数组来管理这些对象。

为了实现这一目的，我们可以使用 malloc 函数来动态分配内存，并创建结构体指针数组。

1. malloc 函数简介malloc 函数是 C 语言中的一个标准库函数，用于动态分配内存。

它的函数原型如下：void *malloc(size_t size);malloc 函数接受一个参数 size，表示需要分配的内存大小（以字节为单位）。

它会在堆（heap）中分配一块指定大小的内存，并返回一个指向该内存块的指针。

如果分配失败，malloc 函数会返回 NULL。

使用 malloc 函数分配的内存块是连续的，可以通过指针进行访问和操作。

为了释放这些内存，我们需要使用 free 函数。

2. 结构体指针数组结构体指针数组是指一个数组，每个元素都是一个指向结构体的指针。

通过使用结构体指针数组，我们可以动态地创建和管理多个结构体对象。

首先，我们需要定义一个结构体类型。

例如，我们定义一个名为 Student 的结构体，包含学生的姓名和年龄：typedef struct {char name[20];int age;} Student;接下来，我们可以使用 malloc 函数动态分配内存，并创建结构体指针数组。

假设我们需要创建 5 个学生对象，可以使用以下代码：int numStudents = 5;Student **students = (Student **)malloc(numStudents * sizeof(Student *));上述代码中，我们首先定义了一个整型变量 numStudents，表示需要创建的学生对象数量。

然后，使用 malloc 函数分配了一个指针数组，数组大小为 numStudents，每个元素的类型为 Student *。

c语言的free函数C语言中的free函数是用于释放动态分配的内存空间的函数。

在C语言中，我们可以使用malloc、calloc等函数来动态分配内存空间，但是在不再需要使用该内存空间时，必须使用free函数来释放这些内存空间，以便让操作系统可以重新使用这些空间。

free函数的声明如下所示：void free(void 某ptr);其中，ptr是一个指向之前通过malloc、calloc等函数分配的内存块的指针。

通过调用free函数，我们可以将所分配的内存块返回给操作系统。

使用free函数的规则如下：1. 在使用malloc、calloc等函数分配内存后，当不再需要使用该内存时，必须使用free函数释放内存空间，以免造成内存泄漏。

2. 只能释放通过malloc、calloc等函数动态分配的内存空间，不能释放指针变量所指向的静态分配的内存空间或者常量字符串所占用的内存。

3. 当多次调用malloc、calloc等函数动态分配内存时，需要按照逆序调用free函数释放内存，以免造成内存覆盖。

4. 不要对同一个指针变量多次调用free函数，否则可能会导致程序崩溃或者出现其他错误。

5. 调用free函数后，不要再使用该指针变量，否则可能会导致程序崩溃或者出现其他错误。

6. 在调用free函数后，可以将指针变量赋值为NULL，以防止在后续的代码中误用该指针。

需要注意的是，调用free函数并不会立即将内存空间返回给操作系统，而是将该内存块标记为可用状态，以供后续的malloc、calloc等函数使用。

操作系统会在需要时将这些可用的内存块重新分配给请求内存的程序。

在使用free函数时，需要遵循上述规则，以确保程序的正确性和性能。

正确使用free函数可以有效避免内存泄漏，提高程序的资源利用率。

malloc函数详解 malloc的全称是memory allocation，中⽂叫动态内存分配，当⽆法知道内存具体位置的时候，想要绑定真正的内存空间，就需要⽤到动态的分配内存。

下⾯具体介绍⼀下malloc函数，，希望帮助⼤家了解。

⼀、原型：extern void *malloc(unsigned int num_bytes);头⽂件：#include <malloc.h> 或 #include <alloc.h> (注意：alloc.h 与 malloc.h 的内容是完全⼀致的。

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

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

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

返回类型是 void* 类型。

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

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

这个在MSDN上可以找到相关的解释，具体内容如下：malloc returns a void pointer to the allocated space, or NULL if there is insufficient memory available. To return a pointer to a type other than void, use a type cast on the return value. The storage space pointed to by the return value is guaranteed to be suitably aligned for storage of any type of object. If size is 0, malloc allocates a zero-length item in the heap and returns a valid pointer to that item. Always check the return from malloc, even if the amount of memory requested is small.三、malloc与new的不同点 从函数声明上可以看出。

分配内存函数
分配内存函数是指在程序中动态地分配内存空间的函数。

在C语
言中，常用的分配内存函数有malloc、calloc、realloc等。

1. malloc函数：malloc函数的原型为void *malloc(size_t size)，功能是分配size字节的内存空间，并返回该空间的起始地址。

这个函数不会对申请到的空间进行初始化。

2. calloc函数：calloc函数的原型为void *calloc(size_t nmemb, size_t size)，功能是分配nmemb个元素，每个元素大小为
size字节的内存空间，并返回该空间的起始地址。

这个函数会将申请
到的空间全部初始化为0。

3. realloc函数：realloc函数的原型为void *realloc(void
*ptr, size_t size)，功能是重新分配ptr指向的内存空间的大小为size字节，并返回新的空间起始地址。

如果ptr指向的空间大小不够，会开辟新的空间并将数据复制到新的空间中，如果大小足够则直接返
回原空间的地址，如果size为0则释放空间并返回NULL。

这些函数在申请内存空间时都可能导致内存分配失败，因此需要
用if判断申请空间是否成功。

例如：
```
int *p = (int*)malloc(sizeof(int)*n);
if(p == NULL){
printf("分配内存失败");
exit(1);
}
```。

c语言动态分配内存函数C语言是一门很古老但依然强大的编程语言，作为一门底层语言，C语言与内存密不可分。

在C语言中，内存分配是一个非常重要的概念。

C语言提供了很多函数来进行内存管理，其中最为常用的便是动态分配内存函数。

本文将围绕动态分配内存函数来进行分步介绍。

1. malloc函数malloc函数是C语言中最为基本的动态分配内存函数，该函数会在堆内存中分配一块指定大小的内存块，并返回该内存块的首地址。

下面是malloc函数的基本语法：void* malloc(unsigned int size);其中，size参数表示要分配的内存块的大小，函数返回一个void型指针，该指针指向已分配的内存块的首地址。

使用malloc函数的方法如下所示：int* arr = (int*)malloc(sizeof(int) * 10);该语句将在堆内存中分配一块大小为40字节（即10个int型变量所占用的内存）的内存块，并将arr指针指向该内存块的首地址。

2. calloc函数calloc函数与malloc函数类似，也是用于动态分配内存的函数。

但与malloc函数不同的是，calloc函数还会对分配的内存块进行初始化。

同时，calloc函数的语法也略有不同：void* calloc(unsigned int num, unsigned int size);其中，num参数表示要分配的内存块的数量，size参数则表示每个内存块的大小。

使用calloc函数的方式如下所示：int* arr = (int*)calloc(10, sizeof(int));该语句将在堆内存中分配一块大小为40字节（即10个int型变量所占用的内存）的内存块，并将该内存块中每个字节都初始化为0，并将arr指针指向该内存块的首地址。

3. realloc函数realloc函数是用于重新分配已经分配的内存块的函数。

该函数接受两个参数，第一个参数是原内存块的地址，第二个参数是新的内存块大小。

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。

函数malloc()和calloc()都可以用来动态分配内存空间,但两者稍有区别。

malloc()函数有一个参数,即要分配的内存空间的大小:void *malloc(size_t size);calloc()函数有两个参数,分别为元素的数目和每个元素的大小,这两个参数的乘积就是要分配的内存空间的大小。

void *calloc(size_t numElements,size_t sizeOfElement);如果调用成功,函数malloc()和函数calloc()都将返回所分配的内存空间的首地址。

函数malloc()和函数calloc()的主要区别是前者不能初始化所分配的内存空间,而后者能。

如果由malloc()函数分配的内存空间原来没有被使用过，则其中的每一位可能都是0;反之,如果这部分内存曾经被分配过,则其中可能遗留有各种各样的数据。

也就是说，使用malloc()函数的程序开始时(内存空间还没有被重新分配)能正常进行,但经过一段时间(内存空间还已经被重新分配)可能会出现问题。

函数calloc()会将所分配的内存空间中的每一位都初始化为零,也就是说,如果你是为字符类型或整数类型的元素分配内存,那麽这些元素将保证会被初始化为0;如果你是为指针类型的元素分配内存,那麽这些元素通常会被初始化为空指针;如果你为实型数据分配内存,则这些元素会被初始化为浮点型的零。

需要包含头文件：#include <syslib.h>＃i nclude<malloc.h>函数声明(函数原型)：void *malloc(int size);说明：malloc 向系统申请分配指定size个字节的内存空间。

返回类型是void* 类型。

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

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

从函数声明上可以看出。

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