C语言——动态内存分配

free函数用来释放动态开辟的内存！！！

头文件也是stdlib.h

 #include<stdio.h> #include<stdlib.h> int main() { int num = 0; scanf("%d", &num); //开辟num个int大小的内存空间 int* parr = (int*)malloc(num * sizeof(int)); //malloc返回类型为void*，这里可以进行强制类型转换 //转换成我们需要的类型 //需要判断内存空间是否开辟成功 if (parr == NULL) { perror("malloc"); return 1; } //开辟成功 else { //给开辟的空间赋值 int i = 0; for (i = 0; i < num; i++) { *(parr + i) = i; printf("%d ", *(parr + i)); } printf("\n"); } free(parr);//释放动态内存开辟的空间 parr = NULL;//后面会讲解，事实上是避免野指针的发生 return 0; }

#include<stdio.h> #include<stdlib.h> int main() { int num = 0; scanf("%d", &num); //开辟num个int大小的内存空间 int* parr = (int*)calloc(num, sizeof(int)); //calloc返回类型为void*，这里可以进行强制类型转换 //转换成我们需要的类型 //需要判断内存空间是否开辟成功 if (parr == NULL) { perror("calloc"); return 1; } //开辟成功 else { //calloc开辟的空间每个字节初始化全部为0 int i = 0; for (i = 0; i < num; i++) { *(parr + i) = i; printf("%d ", *(parr + i)); } printf("\n"); } free(parr);//释放动态内存开辟的空间 parr = NULL;//避免野指针 return 0; }

 #include<stdio.h> #include<stdlib.h> int main() { int num = 0; scanf("%d", &num); //开辟num个int大小的内存空间 int* parr1 = (int*)malloc(num * sizeof(int)); int* parr2 = (int*)calloc(num, sizeof(int)); //calloc返回类型为void*，这里可以进行强制类型转换 //转换成我们需要的类型 //需要判断内存空间是否开辟成功 if (parr1 == NULL) { perror("malloc"); return 1; } if (parr2 == NULL) { perror("calloc"); return 1; } //开辟成功 else { //calloc开辟的空间每个字节初始化全部为0 //malloc开辟空间初值为随机值 int i = 0; printf("malloc:\n"); for (i = 0; i < num; i++) { printf("%d ", *(parr1 + i)); } printf("\n"); printf("calloc:\n"); for (i = 0; i < num; i++) { printf("%d ", *(parr2 + i)); } printf("\n"); } free(parr1);//释放动态内存开辟的空间 free(parr2); parr1 = parr2 = NULL;//避免野指针 return 0; }

calloc开辟的空间每个字节初始化全部为0，而malloc开辟空间初值为随机值
。

所以如果我们
对申请的内存空间的内容要求初始化
，那么可以很方便的使用
calloc函数
来完成任务。

realloc

realloc
函数就可以调整动态开辟内存大小

头文件：stdlib.h

解释：

•
ptr
是要调整的内存地址

•
size
调整之后新的大小

•
返回值为调整之后的内存起始位置

•
这个函数调整原内存空间大小的基础上，还会将原来内存中的数据移动到新的空间

•
realloc在调整内存空间的是存在两种情况：

         情况1：原有空间之后有足够大的空间

         情况2：原有空间之后没有足够大的空间

情况1 ：原有空间之后有足够大的空间

当是情况1的时候，要扩展内存就直接原有内存之后直接追加空间，原来空间的数据不发生变化，返回的地址就是原来内存地址的起始位置。

情况2 ：原有空间之后没有足够大的空间

当是情况2 的时候，原有空间之后没有足够多的空间时，扩展的方法是：在堆空间上另找⼀个合适大小
的连续空间来使用，这样函数返回的是⼀个新的内存地址。

由于上述的两种情况，realloc函数的使用也就要注意⼀些！

//代码1 - 直接将realloc的返回值放到parr中 parr = (int*)realloc(parr, 20 * sizeof(int));

如果我们这样将realloc的返回值放到parr中，编译器就会报出警告，这是因为parr可能没有新开辟空间成功，就会返回NULL，再给parr，那么就会导致原来的数据缺失，
造成内存泄漏。

正确写法：

//代码2 - 先将realloc函数的返回值放在temp中，不为NULL，在放parr中 int* temp = (int*)realloc(parr, 20 * sizeof(int)); if (temp != NULL) { parr = temp; }

简单使用：

#include<stdio.h> #include<stdlib.h> int main() { int* parr = (int*)malloc(10 * sizeof(int)); if (parr == NULL) { perror("malloc"); return 1; } else { int i = 0; for (i = 0; i < 10; i++) { *(parr + i) = i; printf("%d ", *(parr + i)); } printf("\n"); } ///代码1 - 直接将realloc的返回值放到parr中 //错误写法 //parr = (int*)realloc(parr, 20 * sizeof(int)); //代码2 - 先将realloc函数的返回值放在temp中，不为NULL，在放parr中 int* temp = (int*)realloc(parr, 20 * sizeof(int)); if (temp != NULL) { parr = temp; } int i = 0; for (i = 0; i < 20; i++) { *(parr + i) = i; printf("%d ", *(parr + i)); } printf("\n"); free(parr); parr = NULL; return 0; }

常见的动态内存的错误

对NULL指针的解引用操作

void test() { int* p = (int*)malloc(sizeof(int)); *p = 20;//如果p的值是NULL，就会有问题 free(p); }

所以在使用的时候我们首先要判断空间是否开辟成功，不可以对NULL指针进行解引用操作。

正确代码：

void test() { int* p = (int*)malloc(sizeof(int)); if (p == NULL) { perror("malloc");//显示错误 exit(1);//退出程序 } *p = 20;//如果p的值是NULL，就会有问题 free(p); p = NULL; }

对动态开辟空间的越界访问

//越界访问 void test() { int i = 0; int* p = (int*)malloc(10 * sizeof(int)); //开辟10个整型大小的空间 if (NULL == p) { perror("malloc"); exit(1); } for (i = 0; i <= 10; i++) { *(p + i) = i;//当i是10的时候越界访问 } free(p); p = NULL; }

代码退出为3，只开辟了10个整型大小的空间，数组下标从0开始，当下标是10，很明显是越界访问，所以使用的时候要特别注意开辟内存空间的大小。

对非动态开辟内存使用free释放

//对非动态开辟内存使用free释放 void test() { int* p = NULL; int a = 10; p = &a; free(p); //p不是动态内存开辟的 }

我们可以看到对不是动态内存开辟的空间是不可以使用free进行释放的。

使用free释放⼀块动态开辟内存的⼀部分

//使用free释放⼀块动态开辟内存的⼀部分 void test() { int* p = (int*)malloc(10 * sizeof(int)); p++; free(p);//p不再指向动态内存的起始位置 } 

这一种行为也是不被允许的，free应该释放掉动态内存开辟的所有部分，我们使用的时候需要特别注意。

对同⼀块动态内存多次释放

//对同一块动态内存开辟的空间进行重复释放 void test() { int* p = (int*)malloc(10 * sizeof(int)); free(p); free(p);//重复释放 }

动态开辟内存忘记释放（内存泄漏）

// 动态开辟内存忘记释放（内存泄漏） void test() { int* p = (int*)malloc(sizeof(int)); if (NULL != p) { *p = 20; } //调用了test函数进行了动态内存开辟 //但是没有进行释放 }

动态开辟的空间⼀定要释放，并且正确释放！！！

malloc和free成对使用！！！

动态内存相关题目分析

题目一

void GetMemory(char* p) { p = (char*)malloc(100); } void test(void) { char* str = NULL; GetMemory(str); strcpy(str, "hello world"); printf(str); }

我们可以看到这一段代码是有问题的，程序崩溃了，并且没有输出内容。这是为什么呢？

我们一起来分析分析，首先指针变量str最开始给的是NULL，希望通过GetMemory函数获得一块内存空间，在GetMemory函数中，动态申请空间给p，事实上，str和p指向的不是同一块内存空间，想把”hello world”复制到str中，str在函数调用以后依然是NULL，所以不能对空指针进行解引用，发生错误，除此之外，这里的代码还没有对动态申请的空间进行释放，这也是存在问题的，会导致内存泄漏的问题。

总结：

1.对空指针进行解引用

2.没有对动态申请的空间进行释放，会导致内存泄漏的问题。

修改：

1.

void GetMemory(char p) { *p = (char*)malloc(100); //操作的是同一个地址 } void test(void) { char* str = NULL; GetMemory(&str);//指针变量传地址 strcpy(str, "hello world"); printf(str); free(str);//动态申请内存空间进行释放 str = NULL; } int main() { test(); return 0; }

2.

char* GetMemory() { char* p = (char*)malloc(100); return p; } void test(void) { char* str = NULL; str = GetMemory();//str得到一块内存空间 strcpy(str, "hello world"); printf(str); free(str);//动态申请内存空间进行释放 str = NULL; } int main() { test(); return 0; }

两种修改方式都可以达到我们想要的效果。

题目二

char* GetMemory(void) { char p[] = "hello world"; return p; } void test(void) { char* str = NULL; str = GetMemory(); printf(str); } int main() { test(); return 0; }

这一段代码也没有达到我们想要的效果，打印的是乱码，说明是存在问题的。

我们一起来分析分析：这里面进入GetMemory函数，函数里面创建了一个字符数据，这里p就是函数内部的局部变量，存放在内存的栈区，当函数调用结束，这一块地址相应的内容就会被销毁，还给操作系统，操作系统存放其他数据，是随机的，也就出现了乱码。

题目三

void GetMemory(char p, int num) { *p = (char *)malloc(num); } void test(void) { char *str = NULL; GetMemory(&str, 100); strcpy(str, "hello"); printf(str); }

这一段代码乍一看，看起来没有什么问题，传str地址，调用GetMemory函数，开辟100字节大小的空间，事实上，这一段代码存在的问题就是没有对动态开辟的内存进行释放，存在内存泄漏的问题。

正确代码：

void GetMemory(char p, int num) { *p = (char*)malloc(num); } void test(void) { char* str = NULL; GetMemory(&str, 100); strcpy(str, "hello"); printf(str); free(str); str = NULL; } int main() { test(); return 0; }

题目四

void test(void) { char* str = (char*)malloc(100); strcpy(str, "hello"); free(str); if (str != NULL) { strcpy(str, "world"); printf(str); } } int main() { test(); return 0; }

这一段代码又有什么问题呢？

这一段代码的主要问题是str没有及时置为空，str成为野指针，指向一块内存空间，后面再次使用strcpy就造成了非法访问，所以使用free释放动态内存开辟的空间时，要将相应的指针及时置为空，同时更好的修改代码，在malloc之后要判断是否创建空间成功。

修改：

//修改 void test(void) { char* str = (char*)malloc(100); if (str == NULL) { perror("malloc"); exit(1);//创建失败退出程序 } strcpy(str, "hello"); printf(str); //printf("world"); free(str);//str及时置为空，避免str成为野指针 str = NULL; if (str != NULL) { strcpy(str, "world"); printf(str); } } int main() { test(); return 0; }

柔性数组

定义

C99 中，结构中的最后⼀个元素允许是未知大小的数组，叫做『柔性数组』成员

//柔性数组 struct st_type { int i; int a[0];//柔性数组成员 }; //一些编译器可能报错，可以改成： struct st_type { int i; int a[];//柔性数组成员 };

特点

•
结构中的柔性数组成员前面必须至少⼀个其他成员。

•
sizeof 返回的这种结构大小不包括柔性数组的内存。

•
包含柔性数组成员的结构⽤malloc ()函数进行内存的动态分配，并且分配的内存应该大于结构的大小
以适应柔性数组的预期大小。

typedef struct st_type { int i; int a[0];//柔性数组成员 }type_a; int main() { printf("%zd\n", sizeof(type_a));//输出的是4 return 0; }

使用

typedef struct st_type { int i; int a[0];//柔性数组成员 }type_a; //代码1： int main() { int i = 0; type_a* p = (type_a*)malloc(sizeof(type_a) + 100 * sizeof(int)); if (p == NULL) { perror("malloc"); exit(1); } //业务处理 p->i = 100; for (i = 0; i < 100; i++) { p->a[i] = i; printf("%5d ", p->a[i]); } free(p); return 0; }

柔性数组成员a相当于获得100个整型元素的连续空间

优势

实现上面的功能，我们也可以使用下面的代码：

//代码2 typedef struct st_type { int i; int* p_a; }type_a; int main() { type_a* p = (type_a*)malloc(sizeof(type_a)); if (p == NULL) { perror("malloc"); exit(1); } p->i = 100; p->p_a = (int*)malloc(p->i * sizeof(int)); if (p->p_a == NULL) { perror("malloc"); exit(1); } //业务处理 for (int i = 0; i < 100; i++) { p->p_a[i] = i; printf("%5d", p->p_a[i]); } //释放空间 free(p->p_a); p->p_a = NULL; free(p); p = NULL; return 0; }

它们可以达到同样的效果，那么使用第一段代码有什么优势呢？

第⼀个好处是：方便内存释放

如果我们的代码是在⼀个给别⼈用的函数中，你在里面做了⼆次内存分配，并把整个结构体返回给用户
。用户调用free可以释放结构体，但是用户并不知道这个结构体内的成员也需要free，所以你不能
指望用户来发现这个事。所以，如果我们把结构体的内存以及其成员要的内存⼀次性分配好了，并返
回给用户⼀个结构体指针，用户做⼀次free就可以把所有的内存给释放掉。

第二个好处是：有利于提高访问速度.

连续的内存有益于提高访问速度，也有益于减少内存碎片。