对动态开辟空间的越界访问

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就可以把所有的内存也给释放掉。

第二个好处是：这样有利于访问速度.

连续的内存有益于提高访问速度，也有益于减少内存碎片。（其实，我个人觉得也没多高了，反正

你跑不了要用做偏移量的加法来寻址）

总结

关于动态内存管理就讲解到这儿，欢迎各位留言交流以及批评指正，如果文章对您有帮助或者觉得作者写的还不错可以点一下关注，点赞，收藏支持一下。

动态内存管理（下）