对动态开辟空间的越界访问
1. void test() 2. { 3. int i = 0; 4. int *p = (int *)malloc(10*sizeof(int)); 5. if(NULL == p) 6. { 7. exit(EXIT_FAILURE); 8. } 9. for(i=0; i<=10; i++) 10. { 11. *(p+i) = i; 12. } 13. free(p); 14. }
总共增加了10个元素，下标最多遍历到9，所以当i=10的时候越界访问了，程序就崩掉了
对非动态开辟内存使用free释放
1. void test() 2. { 3. int a = 10; 4. int *p = &a; 5. free(p); 6. }
这里呢p为非动态开辟内存，不能用free释放，不然程序会崩溃
使用free释放一块动态开辟内存的一部分
1. void test() 2. { 3. int *p = (int *)malloc(100); 4. p++; 5. free(p); 6. }
此时p不再指向动态内存的起始位置 ，如果运行程序就会崩掉
对同一块动态内存多次释放
1. void test() 2. { 3. int *p = (int *)malloc(100); 4. free(p); 5. free(p); 6. }
这里p进行了重复释放，程序一样会崩掉
动态开辟内存忘记释放（内存泄漏）
1. void test() 2. { 3. int *p = (int *)malloc(100); 4. if(NULL != p) 5. { 6. *p = 20; 7. } 8. } 9. int main() 10. { 11. test(); 12. while(1); 13. }
注意：malloc申请的动态内存只有两种释放方式：1、程序结束 2、用free进行释放
而这里程序既未结束，也没用free进行释放，忘记释放不再使用的动态开辟的空间会造成内存泄漏。
切记：
动态开辟的空间一定要释放，并且正确释放 。
几个经典的笔试题
题一
1. void GetMemory(char *p) 2. { 3. p = (char *)malloc(100); 4. } 5. void Test(void) 6. { 7. char *str = NULL; 8. GetMemory(str); 9. strcpy(str, "hello world"); 10. printf(str); 11. }
运行后我们发现，出错了
这里我们注意： 形参是实参的临时拷贝，代码对p进行了操作，但是对str毫无影响
那么就会存在以下两个问题
而且这里由于GetMemory函数已经结束，已经找不到释放的位置，此处无法释放
题目二
1. char *GetMemory(void) 2. { 3. char p[] = "hello world"; 4. return p; 5. } 6. void Test(void) 7. { 8. char *str = NULL; 9. str = GetMemory(); 10. printf(str); 11. }
运行结果发现
解释与图解如下
这就好比你租的房子到期了，房东将你的东西全部清出去，你还没来得及归换，这时候呢你这件房的钥匙，但是里面的东西不是你，如果你强行访问，就会存在非法访问
题目三
1. void GetMemory(char **p, int num) 2. { 3. *p = (char *)malloc(num); 4. } 5. void Test(void) 6. { 7. char *str = NULL; 8. GetMemory(&str, 100); 9. strcpy(str, "hello"); 10. printf(str); 11. }
这里的问题就很明显了，没有释放动态内存块
题目四
1. void Test(void) 2. { 3. char *str = (char *) malloc(100); 4. strcpy(str, "hello"); 5. free(str); 6. if(str != NULL) 7. { 8. strcpy(str, "world"); 9. printf(str); 10. } 11. }
这里的问题也很明显，str提前释放了。这就相当于我点了个外卖，外卖员告诉我餐放楼
下了，当我去找的时候餐已经被别人拿走了，我知道外卖的地址，却没有外卖
C/C++程序的内存开辟
C/C++程序内存分配的几个区域：
1. 栈区（stack）：在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结
束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是
分配的内存容量有限。 栈区主要存放运行函数而分配的局部变量、函数参数、返回数据、返
回地址等。
2. 堆区（heap）：一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收 。分
配方式类似于链表。
3. 数据段（静态区）（static）存放全局变量、静态数据。程序结束后由系统释放。
4. 代码段：存放函数体（类成员函数和全局函数）的二进制代码。
有了这幅图，我们就可以更好的理解在《C语言初识》中讲的static关键字修饰局部变量的例子了。
实际上普通的局部变量是在栈区分配空间的，栈区的特点是在上面创建的变量出了作用域就销毁。
但是被static修饰的变量存放在数据段（静态区），数据段的特点是在上面创建的变量，直到程序
结束才销毁
所以生命周期变长。
柔性数组
也许你从来没有听说过柔性数组（flexible array）这个概念，但是它确实是存在的。
C99 中，结构中的最后一个元素允许是未知大小的数组，这就叫做『柔性数组』成员。
例如下面的就是柔性数组
1. typedef struct st_type 2. { 3. int i; 4. int a[0];//柔性数组成员 5. }type_a;
有些编译器会报错无法编译可以改成：
1. typedef struct st_type 2. { 3. int i; 4. int a[];//柔性数组成员 5. }type_a;
柔性数组的特点
结构中的柔性数组成员前面必须至少一个其他成员。
sizeof 返回的这种结构大小不包括柔性数组的内存。
包含柔性数组成员的结构用malloc ()函数进行内存的动态分配，并且分配的内存应该大于结构的大
小，以适应柔性数组的预期大小。
例如
1. typedef struct st_type 2. { 3. int i; 4. int a[0];//柔性数组成员 5. }type_a; 6. printf("%d\n", sizeof(type_a));//输出的是4
柔性数组的使用
1. 代码1 2. int i = 0; 3. type_a *p = (type_a*)malloc(sizeof(type_a)+100*sizeof(int)); 4. //业务处理 5. p->i = 100; 6. for(i=0; i<100; i++) 7. { 8. p->a[i] = i; 9. } 10. free(p);
这样柔性数组成员a，相当于获得了100个整型元素的连续空间。
柔性数组的优势
上述的 type_a 结构也可以设计为：
1. 代码2 2. typedef struct st_type 3. { 4. int i; 5. int *p_a; 6. }type_a; 7. type_a *p = (type_a *)malloc(sizeof(type_a)); 8. p->i = 100; 9. p->p_a = (int *)malloc(p->i*sizeof(int)); 10. //业务处理 11. for(i=0; i<100; i++) 12. { 13. p->p_a[i] = i; 14. } 15. //释放空间 16. free(p->p_a); 17. p->p_a = NULL; 18. free(p); 19. p = NULL;
上述 代码1 和 代码2 可以完成同样的功能，但是 方法1 的实现有两个好处
第一个好处是：方便内存释放
如果我们的代码是在一个给别人用的函数中，你在里面做了二次内存分配，并把整个结构体返回给
用户。用户调用free可以释放结构体，但是用户并不知道这个结构体内的成员也需要free，所以你
不能指望用户来发现这个事。所以，如果我们把结构体的内存以及其成员要的内存一次性分配好
了，并返回给用户一个结构体指针，用户做一次free就可以把所有的内存也给释放掉。
第二个好处是：这样有利于访问速度.
连续的内存有益于提高访问速度，也有益于减少内存碎片。（其实，我个人觉得也没多高了，反正
你跑不了要用做偏移量的加法来寻址）
总结
关于动态内存管理就讲解到这儿，欢迎各位留言交流以及批评指正，如果文章对您有帮助或者觉得作者写的还不错可以点一下关注，点赞，收藏支持一下。
