3.对非动态开辟的空间使用free
如下代码所示，a是栈区上的数据，但是我们对a进行了free，那么最终的结果就是程序挂了
#include<stdlib.h> int main() { int a = 0; int* p = &a; free(p); p = NULL; return 0; }
4.使用free释放一块动态开辟内存的一部分
如下代码所示，我们在赋值的过程中p移动了，最终free的p指向的是动态开辟内存的一部分，那么此时程序就会挂了
#include<stdio.h> #include<stdlib.h> int main() { int* p = (int*)malloc(100); if (p == NULL) { perror("malloc"); return 1; } int i = 0; for (i = 0; i < 20; i++) { *p = i + 1; p++; } free(p); p = NULL; return 0; }
5.对同一块内存多次释放
如下图所示，对p进行了两次释放，那么最终结果就是程序挂了
#include<stdio.h> #include<stdlib.h> int main() { int* p = (int*)malloc(100); if (p == NULL) { perror("malloc"); return 1; } free(p); free(p); return 0; }
6.动态开辟内存忘记释放（内存泄漏）
如下代码所示，有两处错误
第一处错误是没有释放malloc出来的空间
第二处错误是我们后续无法找到malloc出来的空间了，无法后续进行释放
#include<stdio.h> #include<stdlib.h> void test() { int* p = (int*)malloc(40); } int main() { test(); return 0; }
四、一些经典的题目
题1
#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; }
这段代码最终的结果是程序挂了
这段代码有两处地方错误
第一处是str应该传传二级指针。因为我们是需要改变的str里面的值的。所以要传str的地址过去，而我们没有传str的地址过去。这就导致了str还是一个NULL，因此我们使用strcpy的时候，将hello world放到空指针处肯定会导致程序挂了
第二处是我们的开辟的空间指向给了p这个指针，但是p是一个局部变量，随着函数的结束，p的值也就找不到了。也就是说我们这里以后也找不到动态开辟的空间了。这就导致了内存泄漏
当然在这个代码中我们还需要注意的是printf(str)这种写法。
我们平时打印的都是printf("hehe\n")这种形式的，这两种写法都一样的，printf接受hehe传的也是首元素的地址。所以我们直接传一个str这个首元素地址也是可以的。
题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; }
对于这个题，我们最终的运行结果是随机值，这类题是属于返回栈空间地址的问题
我们在GetMemory函数中创建了一个数组，这个数组是在栈区上创建的，然后我们返回这个数组的地址。我们的确可以成功接收这个地址，但是问题是，这个地址所指向的空间已经被销毁了。不属于我们的空间了。而我们这时候在打印的话，就会出现随机值。
要解决这个问题，修改这段代码的话，我们有多种方法，我们可以为p加上static修饰一下。这样这个数组就在静态区了。不会被销毁了。
我们也可以将这个数组变成一个指针来接收，因为字符串常量本来就在只读数据区，我们的指针只是接收这个地址的。所以也是可以的
类似的例子还有下面这个
#include<stdio.h> int* test() { int a = 10; return &a; } int main() { int* p = test(); printf("%d", *p); }
这个也是返回了栈空间的地址。所以理论上说他应该也是随机值，但是我们运行后会发现，结果是10。这其实是一种偶然。因为我们创建好test的栈帧以后，在test的栈帧里面创建了a的栈帧。然后我们返回a的地址的时候，我们还没有破坏修改a的栈帧。所以数据还在，所以我们打印出来的还是10
但是我们一旦破坏了这个栈帧。结果就改变了
题3
#include<stdio.h> #include<stdlib.h> #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; }
这段代码从运行结果上来看，是没有什么问题的。
这段代码出现的问题是存在内存泄漏，我们动态开辟了空间，但是没有free掉
题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; }
这段代码从运行结果上来说，可以输出world。但是还是存在一定的问题的
因为我们动态开辟了一个空间，但是我们拷贝完hello之后就将他释放掉了，这块空间已经不归str管理了，但是str还有这块空间的地址，我们还判断了str不为空时，进行拷贝world，这个判断肯定是为真的，但是此时已经造成了非法访问了。
修改方式应该是free之后，将str置为NULL
五、C/C++程序的内存开辟
1. 栈区（stack）：在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。 栈区主要存放运行函数而分配的局部变量、函数参数、返回数据、返回地址等。
2. 堆区（heap）：一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收 。分配方式类似于链表。
3. 数据段（静态区）（static）存放全局变量、静态数据。程序结束后由系统释放。
4. 代码段：存放函数体（类成员函数和全局函数）的二进制代码。
这样我们也就理解了之前所说的static修饰局部变量会使生命周期变长的原因了
实际上普通的局部变量是在栈区分配空间的，栈区的特点是在上面创建的变量出了作用域就销毁。
但是被static修饰的变量存放在数据段（静态区），数据段的特点是在上面创建的变量，直到程序结束才销毁
所以生命周期变长
六、柔性数组
1.柔性数组的概念以及声明
C99 中，结构中的最后一个元素允许是未知大小的数组，这就叫做『柔性数组』成员
如下代码所示，柔性数组的声明有两种方式，一种是数组后面直接加[ ] ，另外一种是数组后面的[]里面的数据写为0
struct S1 { int i; char c; int a[]; };
struct S2 { int i; char c; int a[0]; };
2.柔性数组的特点
1.结构中的柔性数组成员前面必须至少一个其他成员。
2.sizeof 返回的这种结构大小不包括柔性数组的内存。
3.包含柔性数组成员的结构用malloc ()函数进行内存的动态分配，并且分配的内存应该大于结构的大小，以适应柔性数组的预期大小。
对于1、2两个特点
在下面这段代码中，我们定义了一个结构体，我们计算这个结构体的大小最终结果是4
可见只包含了n的大小，这也说明了有柔性数组成员的前面必须至少有一个其他成员。
#include<stdio.h> struct S { int n; char arr[]; }; int main() { printf("%d\n", sizeof(struct S)); }
对于特点3
下面这段代码就是为这个结构体开辟一块空间
#include<stdio.h> #include<stdlib.h> struct S { int n; char arr[]; }; int main() { struct S* ps = (struct S*)malloc(sizeof(struct S) + sizeof(char) * 10); }
他的内存是这样的
3.柔性数组的使用
如下代码所示，我们创建了一个柔性数组，并且给他开辟了空间
当我们想要更多的空间时候，使用realloc增容
最后释放这块空间就可以了
#include<stdio.h> #include<stdlib.h> struct S { int n; char arr[]; }; int main() { struct S* ps = (struct S*)malloc(sizeof(struct S) + sizeof(char) * 10); if (ps == NULL) { perror("malloc"); } ps->n = 100; int i = 0; for (i = 0; i < 10; i++) { ps->arr[i] = 'W'; } struct S* p = (struct S*)realloc(ps, sizeof(struct S) + sizeof(char) * 20); if (p == NULL) { perror("realloc"); return 1; } ps = p; p = NULL; for (i = 10; i < 20; i++) { ps->arr[i] = 'Q'; } for (i = 0; i < 20; i++) { printf("%c ", ps->arr[i]); } free(ps); ps = NULL; return 0; }
4.柔性数组的优点
我们了解了柔性数组的使用以后，我们可能也知道这样的使用也跟柔性数组差不多
#include<stdio.h> #include<stdlib.h> struct S { int n; char* arr; }; int main() { struct S* ps = (struct S*)malloc(sizeof(struct S)); if (ps == NULL) { perror("ps malloc"); return 1; } ps->n = 10; ps->arr = (char*)malloc(sizeof(char) * 10); if (ps->arr == NULL) { perror("ps->arr malloc"); return 1; } int i = 0; for (i = 0; i < 10; i++) { ps->arr[i] = 'Q'; } for (i = 0; i < 10; i++) { printf("%c ", ps->arr[i]); } printf("\n"); char* ptr = (char*)realloc(ps->arr, sizeof(char) * 20); if (ptr == NULL) { perror("realloc"); return 1; } ps->arr = ptr; ptr = NULL; for (i = 10; i < 20; i++) { ps->arr[i] = 'W'; } for (i = 10; i < 20; i++) { printf("%c ", ps->arr[i]); } free(ps->arr); ps->arr = NULL; free(ps); ps = NULL; return 0; }
但是呢他相比较柔性数组还是有一定的缺点的
柔性数组：
一次malloc、一次free、内存连续
上面这个代码的方式
两次malloc、两次free、内存不连续
第一个好处是：方便内存释放
如果我们的代码是在一个给别人用的函数中，你在里面做了二次内存分配，并把整个结构体返回给用户。用户调用free可以释放结构体，但是用户并不知道这个结构体内的成员也需要free，所以你不能指望用户来发现这个事。所以，如果我们把结构体的内存以及其成员要的内存一次性分配好了，并返回给用户一个结构体指针，用户做一次free就可以把所有的内存也给释放掉。
第二个好处是：这样有利于访问速度
连续的内存有益于提高访问速度，也有益于减少内存碎片。但是其实也没有提高多高了，因为后续还是需要使用偏移量的加法寻址
总结
本小节，讲解了动态内存管理，malloc、calloc、realloc、free函数的使用、柔性数组、C/C++的内存开辟、以及常见的动态内存管理错误
如果对你有帮助的话，不要忘记点赞加收藏哦！！！
想获得更多优质内容，不要忘记关注我哦！！！
