笔记22-1（C语言进阶 动态内存管理）
目录
注
为什么存在动态内存分配
动态内存函数的介绍
malloc和free
calloc
realloc
常见的动态内存错误
1.对NULL指针的解引用操作
2.对动态开辟空间的越界访问
3.使用free函数释放了非动态开辟的空间
4.使用free函数释放一块动态开辟的内存的一部分
5.对同一块动态开辟的空间，多次释放
6.动态开辟的内存忘记释放（内存泄漏 - 比较严重）
经典的笔试题（可供参考：《高质量C++/C 编程指南》）
题目1：运行Test函数的结果？（p = (char*)malloc(100)）
题目2：运行Test函数的结果？(返回栈空间地址的问题)
3.程序存在问题 - 无free函数
4.程序存在问题 - 空间提前释放
内存区域划分
柔性数组（flexible array）
柔性数组的特点
柔性数组的优点
注
本笔记参考：B站up：鹏哥C语言
为什么存在动态内存分配
我们已经掌握的内存开辟方法有：
int val = 20;//在栈空间上开辟4个字节
char arr[10] = { 0 };//在栈空间上开辟10个字节的连续空间但是上述开辟空间的方式有两个特点：
- 空间开辟的大小是固定的。
- 数组在声明的时候，必须指定数组的长度，它所需要的内存在编译时再分配。
但是在上一篇笔记中我们提到，有时候我们需要的空间大小只有在运行程序时才能知道，这时候在编译时开辟空间的方法就不能满足我们的需求了。
而这种时候，就需要动态内存开辟。
动态内存函数的介绍
复习知识点：内存区域的划分
malloc和free
malloc - 负责动态内存开辟的函数
这个函数会向内存申请一块连续可用的空间，并返回指向这块空间的指针。
- 如果开辟成功，返回一个指向已开辟空间的指针；
- 如果开辟失败，则返回一个NULL指针（因此 malloc函数 的返回值一定要做检查）。
- 返回值的类型是void*，所以malloc函数并不知道开辟空间的类型，类型是在具体使用的时候由使用者自己决定的。
- 如果参数 size 为 0 ，malloc函数的行为是标准未定义的，这时候就取决于编译器了。（参数size - 需要开辟的字节数）
free - 负责释放和回收动态内存的函数
- 如果参数 ptr 正常指向malloc函数开辟的动态内存空间，则将空间还给操作系统；
- 如果参数 ptr 指向的空间不是动态开辟的，则会导致未定义的行为；
- 如果参数 ptr 是NULL指针，则函数什么事都不做。
malloc函数和free函数都在头文件 stdlib.h 中被声明 （这两个函数总是成对使用）。
简单的使用例
#include
#include
int main()
{
//假设开辟10个整型的空间
int arr[10];//在栈区上开辟
//如果使用动态内存开辟：
int* p = malloc(10*sizeof(int));
return 0;
} 注：
如果是接收的指针是void*的指针，则无法解引用，故不使用void*进行接收；
之所以使用int*，是为了以整型指针的方式使用传回来的指针（因为要求是开辟10个整型的空间）；
在一些编译器上，为了防止出现警告，最好在malloc函数前面加上一个强制类型转换，如：
int* p = (int*)malloc(10*sizeof(int));如果空间开辟成功，相当于在堆区上找了一块40个字节的空间，返回了这块空间的起始地址：
所以如果要使用 malloc函数开辟的这40个字节的空间时，应该：
//接之前的代码
if (p == NULL)//判断空间是否开辟失败
{
perror("main");
//perror函数会以 main:xxxxxxxx 的格式打印
}
//可以使用
int i = 0;
for ( i = 0; i < 10; i++)
{
*(p + i) = i;
//以整型指针的方式往后逐个访问每一个元素
}
for ( i = 0; i < 10; i++)
{
printf("%d ", p[i]);//p[i] 等价于 *(p + i)
}
//当不需要使用以开辟的空间时，需要回收空间
free(p);
p = NULL;//自己动手，把指针p设置为空指针
//……（之后的代码）其中，对于 free(p);
这种写法把指针p指向的空间还给了操作系统，但此时指针p依然保存着原空间的地址（存在非法访问风险）
ps：如果写入诸如 int* p = malloc(100000000000*sizeof(int)); 这样的代码，有可能开辟空间失败：
没有足够空间。
calloc
calloc函数也是用于动态内存分配的。
- 函数的功能是在堆区上开辟元素个数为 num，每个元素的长度为 size（单位为字节）的一块连续空间，并且把空间的每个字节初始化为0。
- 于malloc函数的区别在于calloc函数会在返回地址之前把申请的空间的每个字节初始化为0。
如果使用malloc函数开辟空间，打印发现：
对于所开辟的空间内部到底有什么，这是我们无法得知的。
但是如果使用calloc函数开辟空间：
调试：
这时所开辟空间的内存全部都被初始化成了0。
使用例
#include
#include
int main()
{
int* p = (int*)calloc(10, sizeof(int));
if (p != NULL)
{
//使用空间
}
free(p);
p = NULL;
return 0;
} realloc
realloc - 改变所开辟的动态内存大小的函数
- realloc函数的出现让动态内存管理更加灵活。
- 有时候我们发现曾经申请的空间太小了，有时候我们又会觉得申请的空间过大了。为了合理地使用内存，就需要对内存的大小做灵活的调整，而 realloc 函数就可以做到对开辟的动态内存的大小进行调整。
- ptr 是要调整的内存地址；
- size 是动态内存调整后的大小；
- 返回值为调整后的内存的起始地址。
- 这个函数在调整动态内存大小的同时，还会将原来在这块动态内存空间中的数据移动到新的空间内。
◆realloc函数在调整内存空间的大小时存在两种情况：
◇情况1：原有空间之后有足够大的空间
这时realloc函数像malloc函数一样会申请空间，并返回这块空间的起始地址。
◇情况2：原有空间之后没有足够空间
这时候realloc函数会在内存中重新寻找一块空间：
（这块空间的大小可以满足要求）
①realloc函数会把原本空间内的内容拷贝到新的空间里；
②然后返回新空间的起始地址，同时把原本开辟的空间还给操作系统。
ps：如果realloc函数始终无法找到合适的空间来调控大小，这时函数就会返回一个NULL指针。这也是为什么不可以用指向原本空间的指针接收realloc函数的返回值，这可能会导致指针连原本的空间都无法找到。
通常会拿一个临时指针接收realloc的返回值，进行判断，如果不是空指针，再将临时指针的地址赋给原本的指针。
如：
执行代码
观察内存
可以发现，ptr 和 p 指向的地址是不同的。
使用例
realloc函数在单独使用时可以达到和malloc函数相似的功能 - 直接在堆区中开辟空间
#include
int main()
{
int* p = (int*)realloc(NULL, 40);
return 0;
} 补充：
参数 size 如果是 0 ：
在C90中，参数 ptr 所指向的空间会被还给操作系统（类似于free），同时返回NULL指针。
在C99或者C11中，函数的执行取决于特定的库的实现。
常见的动态内存错误
1.对NULL指针的解引用操作
int main()
{
int* p = (int*)malloc(1000000000);
int i = 0;
for ( i = 0; i < 10; i++)
{
*(p + i) = i;
//万一指针 p 指向的空间开辟失败，就会出现空指针，
//这时候的操作是对空指针而言的，就是非法访问内存了。
}
return 0;
}需要对malloc函数的返回值进行判断。
2.对动态开辟空间的越界访问
int main()
{
int* p = (int*)malloc(10 * sizeof(int));
if (p == NULL)
return 1;
int i = 0;
for (i = 0; i < 40; i++)
{
*(p + i) = i;
}
return 0;
}越界访问了：
- 只开辟了40个字节的空间，
- 而下面的循环认为开辟了40个整形的空间。
3.使用free函数释放了非动态开辟的空间
int main()
{
int arr[10] = { 0 };//在栈区上开辟了空间
int* p = arr;
//使用 省略代码
free(p);//使用free函数释放了非动态开辟的空间
p = NULL;
return 0;
}这里演示在VS2022下强行执行该代码的结果：
代码挂掉了。
4.使用free函数释放一块动态开辟的内存的一部分
int main()
{
int* p = malloc(10 * sizeof(int));
if (p == NULL)
return 1;
int i = 0;
for (i = 0; i < 5; i++)
{
*p++ = i;
//这种写法确实可以把 i 填入前5个元素
//但是这时候指针 p 的位置也往前走了5个元素
}
free(p);
//这时候就会出现问题
return 0;
}这种写法会出现：
导致指针 p 不在起始位置，从而存在两个风险：
- 不能中途释放；
- 指针 p 原本指向空间的起始位置将无法得知（这意味着这块空间很可能再也无法被找到，即存在内存泄漏的风险）。
如果强制执行，代码也会卡死：
5.对同一块动态开辟的空间，多次释放
int main()
{
int* p = (int*)malloc(100);
//使用代码的部分省略
//释放
free(p);
//再次释放
free(p);
return 0;
}这种写法还是会有问题。
如何防止？只要在free函数使用后，将指针 p 置为NULL指针即可（当一个NULL指针被传入free函数时，什么事也不会发生）。
//释放
free(p);
p = NULL;
//再次释放
free(p);6.动态开辟的内存忘记释放（内存泄漏 - 比较严重）
void test()
{
int* p = (int*)malloc(100);
if (p == NULL)
{
return;
}
//使用代码的部分 - 省略
}
int main()
{
test();
//之后的代码部分 - 也省略
return 0;
}
- malloc函数开辟的空间由指针p维护；
- 而指针p的生命周期在函数内部；
- 一旦函数结束，指针p就会被销毁，此时原本被开辟的空间就无法被维护和寻找了。这就是内存泄漏了。
注意：malloc函数开辟的空间只有两种情况可以销毁
- 通过free函数主动释放；
- 程序结束，生命周期结束。
经典的笔试题（可供参考：《高质量C++/C 编程指南》）
题目1：运行Test函数的结果？（p = (char*)malloc(100)）
void GetMemory(char* p)
{
p = (char*)malloc(100);
}
void Test(void)
{
char* str = NULL;
GetMemory(str);
strcpy(str, "Hello Word");
printf(str);
}
int main()
{
Test();
return 0;
}结果：
代码挂了。
分析：
那么如何改正？
一种改法：
注意：和栈区不同，堆区开辟的空间是不会自动销毁的，所以才可以进行诸如 return p 的操作。
补充：
在上面的代码中，出现了这种写法：printf(str); 其实这种写法是可行的。
例如：
printf("Hello World");打印这样的一串字符串，实际上是存在一个指针p，有：
char* p = "Hello World";即把字符'H'的地址放入p中，printf函数再从指针p指向的这个地址向后打印。
另一种改法：
题目2：运行Test函数的结果？(返回栈空间地址的问题)
char* GetMemory(void)
{
char p[] = "Hello World";
return p;
}
void Test(void)
{
char* str = NULL;
str = GetMemory();
printf(str);
}
int main()
{
Test();
return 0;
}运行结果：
分析：
补充：野指针问题
int* f2(void) { int* ptr; *ptr = 10; return ptr; }在里面指针ptr没有初始化，就是个野指针。
3.程序存在问题 - 无free函数
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;
}4.程序存在问题 - 空间提前释放
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;
}分析：
如果提前所以free函数，会出现：
这题告诉我们：free函数后面一定要进行置为空指针的操作。
内存区域划分
- 栈区（stack）：在执行函数时，函数内部的局部变量的存储单元可以在栈上创建，函数执行结束时执行存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。栈区主要存放运行函数而分配的局部变量、函数参数、返回数据、返回地址等。
- 堆区（heap）：一般由程序员分配及释放，若程序员不释放，程序结束时可能由OS回收。分配方式类似于链表。
- 数据段（静态区）：（static）存放全局变量、静态数据。程序结束后由系统释放。
- 代码段：存放函数体（类成员变量和全局函数）的二进制代码。
解释static关键字修饰局部变量：
普通的局部变量是在栈区上分配空间的，栈区的特点是在上面创建的变量出了作用域就销毁。
但是被static修饰的变量存放在数据段（静态区），数据段的特点是在上面创建的变量，直到程序结束才销毁。
所以可以使用static关键字延长局部变量的生命周期。
柔性数组（flexible array）
C99中，结构中的最后一个元素允许是未知大小的数组，这就叫做【柔性数组】成员。
例如：
struct S
{
int n;
int arr[];//这个数组的大小是未知的
};其中的数组arr就是柔性数组。另外还有一种写法：
struct S
{
int n;
int arr[0];
};其中的arr同样是柔性数组，这两种写法根据编译器的不同而不同。
柔性数组的特点
- 结构中的柔性数组的成员前面必须包含至少一个其他成员。
- sizeof 返回的这种结构大小不包括柔性数组的内存。例如：上面所举的结构S所占空间大小就是4。
- 包含柔性数组成员的结构用 malloc函数 进行内存的动态分配，并且分配的内存应该大于结构的大小，以适应柔性数组的预期大小。
例如：
struct S
{
int n;
int arr[];//柔性数组成员
};
int main()
{
//期望数组arr的大小是10个整型
struct S* ps = (struct S*)malloc(sizeof(struct S) + 10 * sizeof(int));
return 0;
}这时候指针ps指向的空间：
使用开辟的柔性数组：
通过调试可以看到arr数组的变化：
完整的使用例：
struct S
{
int n;
int arr[];//柔性数组成员
};
int main()
{
//期望数组arr的大小是10个整型
struct S* ps = (struct S*)malloc(sizeof(struct S) + 10 * sizeof(int));
ps->n = 10;
int i = 0;
for ( i = 0; i < 10; i++)
{
ps->arr[i] = i;
}
//增加空间
struct S* ptr = realloc(ps, sizeof(struct S) + 20 * sizeof(int));
if (ptr != NULL)
{
ps = ptr;
}
//使用 - 省略
free(ps);
ps = NULL;
return 0;
}存在疑问：
只要这样创建数组
struct S
{
int n;
int* arr;
};之后对指针arr进行动态内存开辟似乎也可以达到同样的效果，那为什么还需要柔性数组呢？
也就是说，此时如果arr还需要指向一块空间，就还需要一个malloc函数专门为arr进行动态开辟。只有这样，才能保证ps指向的空间和arr指向的空间都开辟在堆上。
可以这样使用：
struct S
{
int n;
int* arr;
};
int main()
{
struct S* ps = (struct S*)malloc(sizeof(struct S));
if (ps == NULL)
return 1;
ps->n = 10;
ps->arr = (int*)malloc(10 * sizeof(int));
if (ps->arr == NULL)
return 1;
int i = 0;
for ( i = 0; i < 10; i++)
{
ps->arr[i] = i;
}
int* ptr = realloc(ps->arr, 20 * sizeof(int));
if (ptr != NULL)
{
ps->arr = ptr;
}
//使用 - 使用
//释放
free(ps->arr);
ps->arr = NULL;
free(ps);
ps = NULL;
return 0;
}还需要注意释放问题：
似乎这种方法也可以达成目的。但是，这种方法存在缺点：
- 多次释放，容易出错；
- 在堆区上多次申请空间，容易在空间与空间之间留下空间碎片，而空间碎片被利用的概率较低。一旦空间碎片多了，对于内存的利用率就降低了；
- 内存池 —— 统一申请空间，统一使用与维护空间，维护内存的效率就高了。
空间局部性：当使用了某个位置的内存时，接下来有80%的概率使用这个位置周边内存的数据。
所以如果使用上面所述的做法，n 和 arr 可能在空间上不是连续的，当需要访问时，效率就可能受到影响。
柔性数组的优点
- 方便内存释放；
- 有利于访问速度（同时有益于减少内存碎片）。