为什么要有动态内存分配
我们已经掌握的内存开辟⽅式有：
int val = 20 ; // 在栈空间上开辟四个字节的连续空间 char arr[ 10 ] = { 0 }; // 在栈空间上开辟十 个字节的连续空间
但是上述开辟内存空间的⽅式有两个缺点：
• 空间开辟⼤⼩固定
• 数组声明时，必须指定数组的⻓度，长度⼀旦确定了便不能调整
而实际情况是，很多时候我们所需要的空间⼤⼩只有在程序运⾏后才能知道，为此C语⾔引⼊了动态内存开辟这个概念，让程序员⾃⼰可以申请和释放内存空间，这样就显得比较灵活了。
malloc函数
函数原型：void* malloc(size_t size);
作用：向内存申请一块连续可用的内存空间，并返回指向这块内存空间的指针
包含头文件：<stdlib.h>
注意事项：
1、返回的是无类型指针void*，在使用时一定要强制转换为所需要的类型
2、使用完开辟的内存空间后一定要释放空间，如果不释放会造成内存泄漏
3、如果开辟成功，则返回一个指向开辟好空间的指针
4、如果开辟失败，则返回一个NULL指针
5、size的值为0时，它将分配一个大小为0的内存块，并返回一个指向该内存块的指针。但是需要注意的是，这个指针可能是无效的，因为在分配大小为0的内存块时，并不会真正地分配任何内存空间，所以最终情况还是要看编译器的反应
6、动态内存分配相关的函数，它们要操作或者申请的的内存空间属于内存中的堆区
#include <stdio.h> #include <stdlib.h> int main() { //申请10个整型（40个字节）的空间 int* p = (int*)malloc(10 * sizeof(int)); //判断内存空间是否非开辟成功 if (p == NULL) { perror("malloc"); 如果开辟失败就是用perror函数返回错误信息 return 1; } //使用空间 int i = 0; for (i = 0; i < 10; i++) { *(p + i) = i; } for (i = 0; i < 10; i++) { printf("%d ", p[i]); } return 0; }
free函数
函数原型：void free (void* ptr);
作用：对申请的动态内存空间进行释放
包含头文件：<stdlib.h>
注意事项：
1、如果ptr指向的内存空间不是动态开辟的，那free函数的行为是未定义的
2、如果ptr是NULL指针，则函数什么事都不做
3、free仅释放了空间里数据，但空间的地址仍未释放，需要将指向开辟空间地址的指针置为空
#include <stdio.h> #include <stdlib.h> int main() { //申请10个整型（40个字节）的空间 int* p = (int*)malloc(10 * sizeof(int)); if (p == NULL) { perror("malloc"); return 1; } //使用空间 int i = 0; for (i = 0; i < 10; i++) { *(p + i) = i; } for (i = 0; i < 10; i++) { printf("%d ", p[i]); } free(p); //释放p所指向的动态内存 p = NULL; return 0; }
calloc函数
函数原型：void* calloc (size_t num,size_t size);
作用：为num个大小为size的元素开辟一块空间，并把空间的每个字节初始化为0
包含头文件：<stdlib.h>
注意事项：
1、与malloc函数的区别只在于calloc会在返回地址前，将申请的空间中的每个字节都初始化为0
#include <stdio.h> #include <stdlib.h> int main() { //申请10个整型（40个字节）的空间 int* p = (int*)calloc(10,sizeof(int)); if (p == NULL) { perror("calloc"); return 1; } //使用空间 int i = 0; /*for (i = 0; i < 10; i++) { *(p + i) = i; }*/ for (i = 0; i < 10; i++) { printf("%d ", p[i]); } free(p); //释放p所指向的动态内存 p = NULL;//free只是释放了空间是空间的地址仍未释放 return 0; }
realloc函数
函数原型：void* realloc(void* ptr,size_t size);
作用：使动态内存管理更加灵活，对申请的动态内存大小进行调整
包含头文件：<stdlib.h>
注意事项：
1、返回调整后的内存起始地址，ptr指向要调整的内存空间，size为调整后的大小
2、内存空间调整后，原内存中的数据移动到新空间，并释放原空间
3、ralloc在调整内存空间时存在两种情况：原有空间够和空间不够
①原有空间足够（返回地址为旧地址）
②原有空间不够（返回地址为新地址，但原来指向该地址的指针仍然存在）
#include <stdio.h> #include <stdlib.h> int main() { //malloc申请五个字节的内存空间 int* p = (int*)malloc(5 * sizeof(int)); if (p == NULL) { perror("malloc"); return 1; } int i = 0; for(i = 0; i < 5; i++) { *(p + i) = i + 1; } for (i = 0; i < 5; i++) { printf("%d ", *(p + i)); } int* ptr = (int*)realloc(p, 400); if (ptr != NULL) //扩容成功 { p = ptr; //还是要使用原来的p就把新地址赋值给p ptr = NULL; //此时ptr为空指针所以将ptr设置为空 } else //扩容失败报错 { perror("realloc"); return 1; } free(p); p = NULL; return 0; }
关于“int* ptr = (int*)realloc(p, 400);”和“p = ptr;”解释：
进行扩容时，ptr是指向新空间的指针，如果扩容成功的同时我们还想继续使用原来的p指针只需要将ptr所指向的地址赋值给p（虽然被扩容了原来空间不存在了但是p指针指向的地址仍然保留），此时ptr变成空指针了所以要将NULL赋值给ptr，但是注意在赋值结束后不能对ptr进行free操作否则新申请的内存空间就会被释放且ptr和p都会变成野指针
tips：当realloc函数的第一个参数是NULL指针的时候，功能类似于malloc函数 int*p = (int*)realloc(NULL,40); //malloc(40)
常见的动态内存的错误
对空指针的解引用操作
#include <stdio.h> int main() { int* p = (int*)malloc(40); if (p == NULL) { return 1; } int i = 0; for (i = 0; i < 10; i++) { *(p + i) = i; } return 0; }
如果不添加对p指针的判断，当malloc函数开辟空间失败返回空指针p的时候，下面对于p+i的解引用就变成了对空指针的解引用，但是空指针只能被取地址但是不能被解引用所以出错
tips：
return 0 代表程序正常退出
return 1 代表程序异常退出
free掉部分动态开辟的内存
#include <stdio.h> int main() { int* p = (int*)malloc(40); if (p == NULL) { perror("malloc"); return 1; } int i = 0; for (i = 0; i < 5; i++) { *p = i + 1; p++; } free(p); p = NULL; return 0; }
动态开辟内存未释放（内存泄漏）
#include <stdio.h> void test() { int* p = (int*)malloc(40); if (p == NULL) { return; } //...... if (5 == 3 + 2) { return; } free(p); p = NULL; } int main() { test(); return 0; }
程序运行结束后free(p)的操作没有起作用，或者说test函数结束时开辟的内存空间仍未被释放，这是因为在if(5 == 3+2)的操作时函数直接返回了并未进行free操作，这种未释放开辟的内存空间的问题就叫内存泄漏
动态内存经典笔试题：
#include <stdio.h> #include <string.h> void GetMemory(char* p) { p = (char*)malloc(100); } void Test() { char* str = NULL; GetMemory(str); strcpy(str, "hello world"); printf(str); //语法正确 } int main() { Test(); return 0; }
这个程序的问题在于，str原本是一个空指针，现在将str的值传递给了GetMemory中的指针p该过程属于传值调用（形参是实参的拷贝对形参的操作不会影响实参），然后malloc函数开辟内存空间，当GetMemory函数结束后p指针被释放但开辟的内存空间不会被释放，同时也没有一个指针指向该空间，最后str依然是一个空指针，所以无法将hello world拷贝给str指向的内存空间
#include <stdio.h> 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; }
有关传值调用和传址调用中的指针的值和指针的地址的补充：
指针的值：即指针变量的值，指针str的值为NULL，所以传址调用传递给p的就是NULL。
指针的地址：即对指针&后得到的值，形参是二级指针
我们将实参设置为str的地址、形参设置为char** p，此时p为二级指针它指向一级指针str所在的地址，接着我们对p解引用得到的就是一级指针str所在的地址，就可以实现对str指向空间的修改。
柔性数组
柔性数组是为了配合动态内存管理的使用，满足以下三条要求的数组我们称之为柔性数组：
1、必须位于结构体中
2、必须为最后一个成员（前面必须要有成员）
3、数组的大小必须未知
柔性数组的特点：
1、sizeof返回的结构体大小不包括柔性数组的大小
2、包含柔性数组成员的结构体⽤malloc 函数进⾏内存的动态分配，并且分配的内存应该⼤于结构体的⼤⼩，以适应柔性数组的预期⼤⼩
柔性数组的使用
#include <stdio.h> struct st_type { int i; int a[]; //柔性数组 }; int main() { //使用malloc开辟44个字节的空间 = 结构体成员大小 + 想要的柔性数组大小 struct st_type* p = (struct st_type*)malloc(sizeof(struct st_type) + 10 * sizeof(int)); if (p == NULL) { perror("malloc"); return 1; } //使用过程 int i = 0; p->i = 100; for (i = 0; i < 10; i++) { p->a[i] = i; } //希望结构中的a数组长度变为60个字节 struct st_type* ptr = (struct st_type*)realloc(p,sizeof(struct st_type) + 15 * sizeof(int)); if (ptr != NULL) { p = ptr; ptr = NULL; } else { perror("realloc"); return 1; } return 0; }
同样的我们可以使用以下代码实现和柔性数组一样的功能：
#include <stdio.h> struct st_type { int i; int* a; //柔性数组 //在VS中int a[0]的形式也可以，但是不同编译器可能只能用其中一种 }; int main() { //使用malloc开辟一个大小为空间结构体大小的空间 struct st_type* p = (struct st_type*)malloc(sizeof(struct st_type)); //对开辟失败的判断 if (p == NULL) { perror("malloc"); return 1; } //为结构体成员i赋值 p->i = 100; //使用malloc为柔性数组开辟一个40字节大小的空间 p->a = malloc(10*sizeiof(int)); if(p->a == NULL) { perror("malloc"); return 1; } //给a指向的空间进行初始化，因为a指向的是一片空间所以可以视为数组 for (i = 0; i < 10; i++) { p->a[i] = i; } //后面我们又希望a指向的空间为15个整型 int* ptr = (int*)realloc(p->a,15 * sizeof(int)); if (ptr == NULL) { perror("realloc"); return 1; } else { p->a = ptr; ptr = NULL; } //使用过程 free(p->a); p->a = NULL; free(p) p = NULL; return 0; }
对于前后两者之间的对比：
前者（使用一次malloc）：⽅便内存释放
如果我们的代码是在⼀个给别⼈⽤的函数中，你在⾥⾯做了⼆次内存分配，并把整个结构体返回给⽤⼾。⽤⼾调⽤free可以释放结构体，但是⽤⼾并不知道这个结构体内的成员也需要free，所以你不能指望⽤⼾来发现这个事。所以，如果我们把结构体的内存以及其成员要的内存⼀次性分配好了，并返回给⽤⼾⼀个结构体指针，⽤⼾做⼀次free就可以把所有的内存也给释放掉。
后者（使用多次malloc）：这样有利于访问速度
连续的内存空间有益于提⾼访问速度，也有益于减少内存碎⽚,但其实没提高多少......
内存碎片
malloc申请内存空间时分配的内存空间是随机的，图中空白区域就是分配后剩余的内存碎片：
C/C++中程序内存区域划分
简单了解
栈区（stack）： 在执⾏函数时，函数内局部变量的存储单元都可以在栈上创建，函数执⾏结束时这些存储单元⾃动被释放。栈内存分配运算内置于处理器的指令集中，效率很⾼，但是分配的内存容量有限。 栈区主要存放运⾏函数时需要分配的局部变量、函数参数、返回数据、返回地址等
堆区（heap）： ⼀般由程序员进行内存空间的分配和释放，若程序员不释放，程序结束时可能由操作系统自己回收，分配⽅式类似于链表
数据段/静态区（static）：存放全局变量、静态数据，程序结束后由系统自动释放
代码段：存放函数体（类成员函数和全局函数）的⼆进制代码
