前言
动态内存管理是今后学习数据结构的基础，它弥补了之前学习一般数组的缺点，即不能按需使用内存：数组在初始化时的大小就已经被确定了。这种规定虽然提高了安全性，但对合理高效地使用内存不利，这篇文章将详细讲解几种动态内存管理函数、讲解经典笔试题以加深理解、介绍C/C++内存开辟的特点以及柔性数组的使用
1. 为什么存在动态内存分配
我们已经掌握的内存开辟方式有：
//1. 创建一个变量 int a = 20;//在栈空间上开辟四个字节 //2. 创建一个数组 char arr[10] = { 0 };//在栈空间上开辟10个字节的连续空间
但是上述的开辟空间的方式有两个特点：
- 空间开辟大小是固定的。
- 数组在初始化时，必须指定数组的长度，它所需要的内存在编译时分配。 但事实上，实际应用场景中程序需要的内存空间往往是变化的，若因为上述条件的约束，而在数组初始化时将长度设定很长，这样就浪费了很多空间。所以动态内存分配出现了。例如
int num = 0; scanf("%d", &num); //这种写法是不被允许的
注意：
动态内存分配是在堆区上处理的
栈区：不需要我们维护，一个变量只要进入它的作用域，栈区会自动为它开辟空间，当变量超出了它的作用域后，栈区也会自动回收该空间
堆区：需要我们人为地开辟空间，也一定要人为地归还空间
2. 动态内存函数
2.1 malloc和free
malloc要和free配对使用
malloc和free都声明在stdlib.h 头文件中。
2.1.1 malloc
void* malloc (size_t size);//字节
要点
- 这个函数向内存申请一块连续可用的空间，并返回指向这块空间的指针。
- 如果开辟成功，则返回一个指向开辟好空间的指针(起始地址)。
- 如果开辟失败，则返回一个NULL指针，因此malloc的返回值一定要做检查。
- 返回值的类型是void* ，所以malloc函数并不知道开辟空间的类型，具体在使用的时候使用者自己来决定。
- 如果参数size 为0，malloc将如何做是标准是未定义的，取决于编译器。
2.1.2 free
void free (void* ptr);
要点
- free函数用来释放动态开辟的内存。
- 如果参数ptr 指向的空间不是动态开辟的，那free的行为是未知的。也就是说，先用malloc开辟内存才能用free释放。（但如果free的是空指针，即使没有先malloc也是符合语法的，因为不会发生任何事，就好像对0加减乘除一样）
- 如果参数ptr 是NULL指针，则函数什么事都不做。
2.1.3 用例
#include <stdio.h> int main() { int* ptr = NULL;//初始化指针 ptr = (int*)malloc(1000); if (NULL != ptr)//判断ptr指针是否为空 { int i = 0; for (i = 0; i < num; i++) { *(ptr + i) = 0; } } free(ptr);//释放ptr所指向的动态内存 ptr = NULL;//free掉以后一定要将指针置空 return 0; }
要点
- 内存泄漏：在程序结束前，如果只向内存申请在堆区开辟空间，使用完毕后却不free，没有将内存空间还给堆区，操作系统会认为用户还在使用，这块内存就相当于浪费了，造成内存泄漏。
为什么是程序结束前？因为程序结束后会自动将内存还给操作系统。
- 开辟内存的不同写法
ptr = (int*)malloc(1000); ptr = (int*)malloc(100 * sizeof(int));
- 非法访问内存：仅仅将内存free还不够，因为内存中的内容（如果其他程序没有使用的话），指针存放的地址都没有被改变，free掉使用过的内存仅是向系统传达一个“申请的内存空间已经使用完毕”这个信息。如果后续再使用这个指针p，那么它还是指向那块内存空间的，但这个内存空间已经还给操作系统了，若再访问，则造成非法访问内存。
- 要完全切断ptr和free之前的内存空间的联系，就要将ptr置为空指针。所以这两句是一定要在一起。
free(ptr);//释放ptr所指向的动态内存 ptr = NULL;//free掉以后一定要将指针置空
2.2 calloc
void* calloc (size_t num, size_t size);
要点
- 函数的功能是为num 个大小为size 的元素开辟一块空间，并且把空间的每个字节初始化为0。
- 与函数malloc 的区别只在于calloc 会在返回地址之前把申请的空间的每个字节初始化为全0。
举个例子：
#include <stdio.h> #include <stdlib.h> int main() { int* p = (int*)calloc(10, sizeof(int)); if (NULL != p) { for (int i = 0; i < 10; i++) { printf("%d ", *(p + i));//打印 } } free(p); p = NULL; return 0; }
2.3 realloc
void* realloc (void* ptr, size_t size);
要点
- ptr 是要调整的内存地址
- size 调整之后新大小
- 返回值为调整之后的内存起始位置。如果失败，返回空指针。
- 这个函数调整原内存空间大小的基础上，还会将原来内存中的数据移动到新的空间。
- realloc在调整内存空间的方式有两种：
- 情况1：原有空间之后有足够大的空间
当空间足够大 ，直接再原有内存之后追加空间，直至达到size大小，原来空间的数据不发生变化。返回原有内存的地址
- 情况2：原有空间之后没有足够大的空间
当没有足够空间，在堆区找到一个足够大的连续空间，将原有的数据copy，然后再在它后面拓展空间。这样函数返回的是一个新的内存地址。
由于上述的两种情况，realloc函数的使用就要注意一些。
- 对于以上代码，是两个指针（p和ptr）变量维护一个内存空间，语法上是可以只用一个维护的，但是这样做是很危险的：如果realloc操作失败，返回空指针，这时原本维护内存的指针就变成了空指针，而且没有free，相当于造成了内存泄漏。
- 所以要用一个指针变量专门维护内存空间，还要用一个指针变量接收realloc的返回值。若非要用一个指针变量维护，则需要判断指针是否否为空。
- 上面的程序有个问题，你能找出来吗？
3. 常见错误
3.1 对NULL指针解引用
void test() { int num = 0; scanf("%d", &n); int* p = (int*)malloc(num); *p = 20;//如果p的值是NULL，就会有问题 free(p); }
如果malloc操作失败返回NULL，p的值就为NULL，后续操作都是无效的。
改进
void test() { int num = 0; scanf("%d", &n); int* p = (int*)malloc(num); if(p != NULL)//判断指针是否为空 *p = 20; free(p); }
3.2 越界访问动态开辟空间
void test() { int i = 0; int* p = (int*)malloc(10 * sizeof(int)); //这里只开辟了10个int大小的空间 if (NULL == p) { return 0; } for (i = 0; i <= 10; i++) { *(p + i) = i;//循环11次，当i是10的时候越界访问 } free(p); }
3.3 使用free释放非动态开辟内存
void test() { int a = 10; int* p = &a; free(p);//ok? }
free必须在开辟内存之后使用
3.4 使用free释放一块动态开辟内存的一部分
#include<stdio.h> #include<stdlib.h> int main() { int* p = (int*)malloc(10 * sizeof(int)); if (p == NULL) return 0; for (int i = 0; i < 10; i++) { *p = 1; p++;//改变了起始地址 } free(p); p = NULL; return 0; }
free传入的地址一定要是原来开辟空间的起始地址
3.5 对同一块动态内存多次释放
#include<stdio.h> #include<stdlib.h> int main() { int* p = (int*)malloc(10 * sizeof(int)); if (p == NULL) return 0; free(p);//c第一次 p = NULL; //一堆代码... free(p);//第二次 p = NULL; return 0; }
一个函数内不能多次对同一个内存空间free。这里体现指针置空的好处，第一次将它置零，后面就相当于对k进行无效操作。
3.6 动态开辟内存未释放（内存泄漏）
#include<stdio.h> #include<stdlib.h> int main() { int* p = (int*)malloc(100); if (NULL != p) { *p = 20; } return 0; }
动态开辟的空间一定要正确地free。
4. 笔试题
4.1 题目1
//请问运行Test 函数会有什么样的结果？ #include<stdio.h> #include<stdlib.h> #include<string.h> void GetMemory(char* p) { p = (char*)malloc(100); } void Test(void) { char* str = NULL; GetMemory(str); strcpy(str, "hello world"); printf(str); } int main() { Test(); return 0; }
解读
主函数调用Test函数，然后再调用GetMemory函数。
在Test函数中将存放着NULL地实参str传给Getmemory，而形参是实参的一份临时拷贝，所以Getmemory定义的指针变量p指向的是另外的一个存放着NULL的内存，在函数内部对NULL进行内存开辟是无效的。
GetMemory调用完毕，那块内存已经被销毁，而str指向的内存还是之前存放NULL的内存。strcpy想将一个常量字符串放入NULL中，这是无效操作。
所以程序什么都不会发生，编译器会报内存崩溃错误。
其次这个代码本身是有问题的：开辟内存后没有free。
改进
不难知道，这个程序的目的是将ptr指向的空间拓展，然后存放一个常量字符串。而问题出现在函数传参的过程中，函数没有起到修改原内存内容的作用。有两种改进方法
- 先将一个指针变量的地址传给函数，让它开辟内存空间
在调用GetMemory时，应该传入&str，形参也应该以char**的形式定义，开辟内存维护的指针也应该是*p。
#include<stdio.h> #include<stdlib.h> #include<string.h> void GetMemory(char** p) { *p = (char*)malloc(100); } void Test(void) { char* str = NULL; GetMemory(&str); strcpy(str, "hello world"); printf(str); free(ptr);//free掉 ptr = NULL; } int main() { Test(); return 0; }
- GetMemory的作用是用一个指针变量维护开辟的内存空间，然后返回这个指针，赋值给Test中的str
#include<stdio.h> #include<stdlib.h> #include<string.h> char* GetMemory(char* p)//改变了返回值类型 { p = (char*)malloc(100); return p; } void Test(void) { char* str = NULL; str = GetMemory(str);//将返回值赋值给str strcpy(str, "hello world"); printf(str); free(ptr); ptr = NULL; } int main() { Test(); return 0; }
请思考 ：一般变量在函数调用完毕后会被销毁，那这块开辟的内存空间也会被销毁吗？
4.2 题目2
#include<stdio.h> #include<stdlib.h> #include<string.h> char* GetMemory(void) { char p[] = "hello world"; return p; } void Test(void) { char* str = NULL; str = GetMemory(); printf(str); } int main() { Test(); return 0; }
解读
p数组是一个局部数组，GetMemory被调用完毕以后，返回的是一个野指针，打印出来的是随机值
4.3 题目3
#include<stdio.h> #include<stdlib.> #include<string.h> void GetMemory(char** p, int num) { *p = (char*)malloc(num); } void Test(void) { char* str = NULL; GetMemory(&str, 100); strcpy(str, "hello"); printf(str); } int main() { Test(); return 0; }
解读
程序使str指向Getmemory开辟的内存空间并放入一个常量字符串，打印成功
错误在于未释放开辟的空间
4.4 题目4
#include<stdio.h> #include<stdlib.h> #include<string.h> 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; }
解读
这是一个十分奇怪的错误：copy完常量字符串到开辟的内存空间以后就free掉了，紧接着又使用这块空间，造成非法访问内存
free的作用仅是向操作系统传达“已经使用完毕”这一信息，其内存空间的内容暂时不会改变（如果其他程序没有用到这块内存的话），紧接着判断指针是否为空，然后world覆盖了hello，打印结果为world
free的同时也要将指针变量置空，因为free没有这个功能
改进
显然，在开辟完空间以后就应该判断str是否为空，而不是在free掉以后再判断。不可直接将free放到程序末尾。本题考点是free的同时将指针变量置空
#include<stdio.h> #include<stdlib.h> #include<string.h> void Test(void) { char* str = (char*)malloc(100); strcpy(str, "hello"); free(str); str = NULL; if (str != NULL) { strcpy(str, "world"); printf(str); } } int main() { Test(); return 0; }
5. C/C++程序的内存开辟
以一段代码为例
C/C++程序内存分配的几个区域：
- 栈区（stack）：在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。
栈区主要存放运行函数而分配的局部变量、函数参数、返回数据、返 回地址等。- 堆区（heap）：一般由程序员分配释放， 若程序员不释放，程序结束时可能由操作系统回收 。分配方式类似于链表。
- 数据段（静态区）（static）存放全局变量、静态数据。程序结束后由系统释放。
- 代码段：存放函数体（类成员函数和全局函数）的二进制代码。
以上图理解static修饰局部变量
实际上普通的局部变量是在栈区分配空间的，栈区的特点是：在栈区创建的变量一旦超出了作用域就会被销毁。但是被static修饰的变量存放在数据段（静态区），数据段的特点是：在静态区创建的变量，直到程序结束才会被销毁。所以生命周期变长。
6. 柔性数组
C99 中，结构中的最后一个元素允许是未知大小的数组，这就叫做柔性数组成员。
例如
typedef struct st_type { int i; int a[0];//柔性数组成员 }type_a;
有些编译器会报错无法编译可以改成：
typedef struct st_type { int i; int a[];//柔性数组成员 }type_a;
6.1 柔性数组的特点
- sizeof 返回的这种结构大小不包括柔性数组的内存大小。
typedef struct st_type { int i; int a[0];//柔性数组成员 }type_a; int main() { printf("%d\n", sizeof(type_a));//输出的是4 return 0; }
- 结构中的柔性数组成员前面必须至少有一个其他成员。
- 包含柔性数组成员的结构用malloc ()函数进行内存的动态分配，并且分配的内存应该大于结构的大小，以适应柔性数组的预期大小。
6.2 柔性数组的使用
#include<stdio.h> #include<stdlib.h> #include<string.h> struct s { int i; int a[0];//柔性数组成员 }; int main() { int i = 0; struct s* p = (struct s*)malloc(sizeof(struct s) + 100 * sizeof(int)); //使用指针变量维护和使用malloc开辟内存要强转 p->i = 100;//修改成员i的值 for (i = 0; i < 100; i++) { p->a[i] = i;//修改成员a的值 } free(p); p = NULL; return 0; }
6.3 柔性数组的优势
以上代码和下面等价，但有所不同。以下面的代码为例与之作比较。
#include<stdio.h> #include<stdlib.h> #include<string.h> typedef struct st_type { int i; int* p_a;//后面把这个指针变量当数组使用 }type_a; int main() { type_a* p = (type_a*)malloc(sizeof(type_a)); //为结构体开辟内存 p->i = 100;//修改成员i p->p_a = (int*)malloc(p->i * sizeof(int)); //为数组成员开辟内存 for (int i = 0; i < 100; i++) { p->p_a[i] = i;//修改数组成员 } //释放空间 free(p->p_a); p->p_a = NULL; free(p); p = NULL; return 0; }
这里将一个数组作为结构成员，并单独为它开辟内存空间，每次通过结构访问成员使用它，这和柔性数组的特性是十分类似的。
不同或者说是前者的优点
- 方便内存释放
注意这个程序开辟了两次空间，一次为结构体，一次为数组，所以需要free两次。但假设这两次内存的开辟都是在一个函数中，当别人使用这个函数不知道要free两次，只free了一次，这会造成问题。所以前者的写法是符合习惯的。开辟一次内存，free一次。
- 提高内存访问速度
能提高，但只能提高一点点。访问一块连续的内存，比访问若干分散的内存速度要快。但以当今的性能，这点速度是很难感知的。所以主要的优点是前者。
结语
动态内存管理是数据结构的基础，一个比较长的链表需要不断地开辟和释放内存，但这么做的意义不仅在于更灵活地使用数组，弥补一般数组不能按需增加长度的缺点，更在于这么做能提高内存的使用效率，这是单纯一个数组无法做到的。
欢迎指正！
如果你有收获的话，不妨给作者一个鼓励吧~
