• C进阶---动态内存管理

    目录

    一、为什么存在动态内存分配

    1.1静动态内存分配区别：

    1.2静态分配的优缺点 

    1.3动态分配优缺点 

    二、动态内存函数的介绍 

    2.1malloc和free 

    2.2calloc 

    2.3realloc 

    三、常见的动态内存错误  

    3.1对NULL指针的解引用操作 

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

    3.3对非动态开辟的内存使用free释放 

    3.4 使用free释放一块动态开辟内存的一部分 

    3.5 对同一块动态内存多次释放 

     3.6 动态开辟内存忘记释放（内存泄漏）

    四、C/C++程序的内存开辟

    五、柔性数组 

    5.1柔性数组概念 

    5.2柔性数组的特点 

    5.3柔性数组的使用 

    5.4柔性数组的优势 

    当我们使用一个空间时，如果还是固定的开辟一定的空间，当使用过小时会浪费很多，当使用过多又要重新开辟空间，动态内存就是可以让我们灵活的使用空间，既不浪费，又能灵活的增加。

    今天，我们就来详细学习动态内存管理。

    一、为什么存在动态内存分配

    我们已经知晓的的内存开辟方式：

    int val = 20;//在栈空间上开辟四个字节
    char arr[10] = {0};//在栈空间上开辟10个字节的连续空间 

    这都是在栈上开辟空间

    栈上开辟空间的方式存在两个特点：

    1. 空间开辟大小是固定的。
    2. 数组在申明的时候，必须指定数组的长度，它所需要的内存在编译时分配。

    为什么要使用动态分配的原因

    1. 当我们事先不知道程序需要多少内存的时；
    2. 当我们希望数据结构没有固定的内存空间上限时；
    3. 当你想更有效地使用你的内存空间时。例如： 如果你为一个一维数组分配的内存空间是 array[20]，而你最终只使用了 10 个内存空间，那么剩下的 10 个内存空间就被浪费了，这些浪费的内存甚至不能被其他程序变量所使用；
    4. 动态创建的列表的插入和删除可以非常容易地通过操作地址来完成，而在静态分配的内存中，插入和删除会导致更多的移动和内存浪费；
    5. 当你想在编程中使用结构和链表的概念时，动态内存分配是必须的。

    1.1静动态内存分配区别：

    序号静态内存分配动态内存分配
    1在静态内存分配中，变量被永久地分配内存，直到程序执行结束/函数调用结束在动态内存分配中，只有当你的程序单元被激活时才会为变量分配内存
    2静态内存分配在程序执行前完成动态内存分配在程序执行过程中完成
    3使用栈来管理静态分配的内存使用堆来管理动态分配的内存
    4较不高效 (less efficient)较高效
    5在静态内存分配中，不存在内存的重用在动态内存分配中，存在内存的重用，而且在不需要时可以内存可以被释放
    6在静态内存分配中，一旦内存被分配，内存大小就不能再改变在动态内存分配中，分配了内存后，内存的大小可以改变
    7在静态内存分配方案中，我们不能重新使用未使用的内存动态内存分配中，允许重复使用内存。用户可以在需要时分配更多的内存。同时，用户也可以在需要时释放内存。
    8在这种内存分配方案中，执行速度比动态内存分配要快在这种内存分配方案中，执行速度要比静态内存分配慢
    9编译时内存分配运行时内存分配
    10静态分配的内存从程序开始保持到程序结束动态分配的内存可以在任意时刻释放
    11静态的内存分配常常用于数组等动态的内存分配常常用于链表等数据结构

    1.2静态分配的优缺点 

    优点

    1. 使用起来简单
    2. 分配和取消分配都由编译器完成
    3. 高效的执行时间
    4. 它使用栈数据结构，在栈上开辟

    缺点

    1. 内存浪费问题
    2. 必须知道确切的内存需求
    3. 一旦初始化后，内存的大小不能调整

    1.3动态分配优缺点 

    优点

    1. 动态分配是在运行时进行的
    2. 只要我们需要，我们就可以分配（创建）额外的存储
    3. 只要我们使用结束了，内存就可以被取消分配（free / delete）动态空间；因此，人们总是可以准确地拥有所需的空间量--不多也不少。
    4. 如果需要，内存大小可以重新分配

    缺点

    1. 由于内存是在运行时分配的，因此需要更多的时间。
    2. 当完成后，内存需要由用户释放。这一点很重要，因为它更有可能变成难以发现的 bug。

    二、动态内存函数的介绍 

    C语言提供了三个动态内存开辟的函数：malloc、calloc、realloc 

    使用时我们要包含头文件：#include 

    2.1malloc和free 

     void* malloc (size_t size);（开辟大小单位是字节）

     cplusplus网站上的介绍 

    这个函数向内存申请一块连续可用的空间，并返回指向这块空间的指针。

    • 如果开辟成功，则返回一个指向开辟好空间的指针。
    • 如果开辟失败，则返回一个NULL指针，因此malloc的返回值一定要做检查。
    • 返回值的类型是 void* ，所以malloc函数并不知道开辟空间的类型，具体在使用的时候使用者自己来决定。
    • 如果参数 size 为0，malloc的行为是标准是未定义的，取决于编译器。

    举个例子： 

    1. #define _CRT_SECURE_NO_WARNINGS
    2. #include <stdio.h>
    3. #include <errno.h>
    4. #include <stdlib.h>
    5.  
    6.  
    7. int main()
    8. {
    9.  
    10. 	//申请
    11. 	int* p = (int*)malloc(20);
    12. 	if (p == NULL)
    13. 	{
    14. 		printf("%s\n", strerror(errno));
    15. 		return 1;
    16. 	}
    17. 	//使用
    18. 	int i = 0;
    19. 	for (i = 0; i < 5; i++)
    20. 	{
    21. 		p[i] = i + 1;
    22. 	}
    23. 	for (i = 0; i < 5; i++)
    24. 	{
    25. 		printf("%d ", p[i]);
    26. 	}
    27. 	
    28. 	//释放
    29. 	free(p);
    30. 	p = NULL;
    31.  
    32. 	return 0;
    33. }

    仔细观察我们可以看到为什么最后多了两行代码？这个free有什么用？ 

     这是C语言提供的另外一个函数free，专门是用来做动态内存的释放和回收的，函数原型如下：

    void free (void* ptr);

    cplusplus网站上的介绍 

    free函数用来释放动态开辟的内存。

    • 如果参数 ptr 指向的空间不是动态开辟的，那free函数的行为是未定义的。
    • 如果参数 ptr 是NULL指针，则函数什么事都不做。

     再看个例子：

    1. int main()
    2. {
    3. 	//代码1
    4. 	int num = 0;
    5. 	scanf("%d", &num);
    6. 	int arr[num] = {0};
    7. 	//代码2
    8. 	int* ptr = NULL;
    9. 	ptr = (int*)malloc(num * sizeof(int));
    10. 	if (NULL != ptr)//判断ptr指针是否为空
    11. 	{
    12. 		int i = 0;
    13. 		for (i = 0; i < num; i++)
    14. 		{
    15. 			*(ptr + i) = 0;
    16. 		}
    17. 	}
    18. 	free(ptr);//释放ptr所指向的动态内存
    19. 	ptr = NULL;//置空避免了野指针
    20. 	return 0;
    21. }

    上面代码中使用的errno能打印出错误信息。介绍一下它的使用方法 

    2.2calloc 

     calloc 函数原型如下：

    void* calloc (size_t num, size_t size);

    • 函数的功能是为 num 个大小为 size 的元素开辟一块空间，并且把空间的每个字节初始化为0。
    • 与函数 malloc 的区别只在于 calloc 会在返回地址之前把申请的空间的每个字节初始化为全0。

     cplusplus网站上的介绍 

    举个例子：

    1. int main()
    2. {
    3. 	int* p = (int*)calloc(10, sizeof(int));
    4. 	if (NULL != p)
    5. 	{
    6. 		//使用空间
    7. 	}
    8. 	free(p);
    9. 	p = NULL;
    10. 	return 0;
    11. }

    运行后： 

    再看一个： 

    1. int main()
    2. {
    3. 	int* p = (int*)calloc(10, sizeof(int));
    4. 	if (p == NULL)
    5. 	{
    6. 		printf("calloc()-->%s\n", strerror(errno));
    7. 		return 1;
    8. 	}
    9. 	//使用
    10. 	int i = 0;
    11. 	for (i = 0; i < 10; i++)
    12. 	{
    13. 		printf("%d ", p[i]);
    14. 	}
    15.  
    16. 	//释放
    17. 	free(p);
    18. 	p = NULL;
    19. 	return 0;
    20. }

    运行后： 

    所以当我们要对申请的内存空间的内容初始化，就可以使用calloc函数来完成任务，方便快捷。

    2.3realloc 

    • realloc函数的出现让动态内存管理更加灵活。
    • 有时会我们发现过去申请的空间太小了，有时候我们又会觉得申请的空间过大了，那为了合理的时候内存，我们一定会对内存的大小做灵活的调整。那 realloc 函数就可以做到对动态开辟内存大小的调整。

      cplusplus网站上的介绍  

    函数原型如下：

    void* realloc (void* ptr, size_t size);

    • ptr 是要调整的内存地址
    • size 调整之后新大小
    • 返回值为调整之后的内存起始位置。
    • 这个函数调整原内存空间大小的基础上，还会将原来内存中的数据移动到 新 的空间。
    • realloc在调整内存空间的是存在两种情况：
    1. 情况1：原有空间之后有足够大的空间
    2. 情况2：原有空间之后没有足够大的空间 

    情况1
    当是情况1 的时候，要扩展内存就直接原有内存之后直接追加空间，原来空间的数据不发生变化。
    情况2
    当是情况2 的时候，原有空间之后没有足够多的空间时，扩展的方法是：在堆空间上另找一个合适大小的连续空间来使用。这样函数返回的是一个新的内存地址。

    扩展步骤：

    1. realloc会找更大的空间
    2. 将原来的数据拷贝到新空间
    3. 释放旧的空间
    4. 返回新空间的地址

    由于上述的两种情况，realloc函数的使用就要注意一些。

    举个例子：

    1. int main()
    2. {
    3. 	int* p = (int*)malloc(20);
    4. 	if (p == NULL)
    5. 	{
    6. 		printf("%s\n", strerror(errno));
    7. 		return 1;
    8. 	}
    9. 	//使用
    10. 	int i = 0;
    11. 	for (i = 0; i < 5; i++)
    12. 	{
    13. 		p[i] = i + 1;
    14. 	}
    15. 	int* ptr = (int*)realloc(p, 40);
    16.  
    17. 	if (ptr != NULL)
    18. 	{
    19. 		p = ptr;
    20. 		//使用
    21. 		for (i = 5; i < 10; i++)
    22. 		{
    23. 			p[i] = i + 1;
    24. 		}
    25. 		for (i = 0; i < 10; i++)
    26. 		{
    27. 			printf("%d ", p[i]);
    28. 		}
    29. 	}
    30. 	
    31. 	//释放
    32. 	free(p);
    33. 	p = NULL;
    34.  
    35. 	return 0;
    36. }

    成功增加20个字节。 


      

    到这里我们考虑下，是不是增加多大的空间都可以？

      

    注意：

    使用动态内存函数分配空间后，要判断返回值是否为NULL，最后要记得释放并置为NULL。

    三、常见的动态内存错误  

    下面我们来看看在动态内存使用时的错误，知晓其错误原因，并在以后避免发生这种错误。 

    3.1对NULL指针的解引用操作 

    1. int main()
    2. {
    3. 	int* p = (int*)malloc(NULL);
    4. 	//可能会出现对NULL指针的解引用操作
    5. 	//所以malloc函数的返回值要判断的
    6. 	int i = 0;
    7. 	for (i = 0; i < 5; i++)
    8. 	{
    9. 		p[i] = i;
    10. 	}
    11. 	free(p);
    12. 	p = NULL;
    13.  
    14. 	return 0;
    15. }

     运行后我们发现会出错，解引用后要对值判断。

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

    1. int main()
    2. {
    3. 	int* p = (int*)malloc(20);
    4. 	if (p == NULL)
    5. 	{
    6. 		printf("%s\n", strerror(errno));
    7. 		return 1;
    8. 	}
    9. 	//可能会出现对NULL指针的解引用操作
    10. 	//所以malloc函数的返回值要判断的
    11. 	int i = 0;
    12. 	//越界访问
    13. 	for (i = 0; i < 10; i++)
    14. 	{
    15. 		p[i] = i;
    16. 	}
    17. 	for (i = 0; i < 10; i++)
    18. 	{
    19. 		printf("%d ", p[i]);
    20. 	}
    21. 	free(p);
    22. 	p = NULL;
    23.  
    24. 	return 0;
    25. }

    我们观察可以看到，开辟了20个字节，使用时却使用到了40字节，越界访问了，出现错误。 

    3.3对非动态开辟的内存使用free释放 

    1. //对非动态开辟内存使用free释放
    2. int main()
    3. {
    4. 	int arr[10] = { 1,2,3,4,5 };
    5. 	int* p = arr;
    6. 	//....
    7. 	free(p);
    8. 	p = NULL;
    9.  
    10. 	return 0;
    11. }

     我们在使用时也要注意free是对动态内存函数释放。

    3.4 使用free释放一块动态开辟内存的一部分 

    1. //使用free释放一块动态开辟内存的一部分
    2. int main()
    3. {
    4. 	int* p = (int*)malloc(40);
    5. 	if (p == NULL)
    6. 	{
    7. 		printf("%s\n", strerror(errno));
    8. 		return 0;
    9. 	}
    10.  
    11. 	int i = 0;
    12. 	//[1] [2] [3] [4] [5] [ ] [ ] [ ] [ ] [ ] 
    13. 	for (i = 0; i < 5; i++)
    14. 	{
    15. 		*p = i + 1;
    16. 		p++;
    17. 	}
    18. 	//释放
    19. 	free(p);
    20. 	p = NULL;
    21.  
    22. 	return 0;
    23. }

     开辟多少，释放多少。

    3.5 对同一块动态内存多次释放 

    1. //对同一块动态内存多次释放
    2. int main()
    3. {
    4. 	int*p = (int*)malloc(20);
    5. 	if (p == NULL)
    6. 	{
    7. 		return 1;
    8. 	}
    9. 	//使用
    10. 	// 
    11. 	free(p);
    12. 	//p = NULL;
    13.  
    14. 	//释放
    15. 	free(p);
    16. 	p = NULL;
    17.  
    18. 	return 0;
    19. }

     释放多次造成错误

     如果释放一次就置为空，第二次释放就不会出现错误。

     3.6 动态开辟内存忘记释放（内存泄漏）

    1. void t1()
    2. {
    3. 	int* p = (int*)malloc(100);
    4. 	if (NULL != p)
    5. 	{
    6. 		*p = 20;
    7. 	}
    8. }
    9. int main()
    10. {
    11. 	t1();
    12. 	while (1);
    13. }

     使用后要记得释放，如果比释放，最终在程序结束后也会被操作系统收回。

    忘记释放不再使用的动态开辟的空间会造成内存泄漏。
    切记：
    动态开辟的空间一定要释放，并且正确释放

    四、C/C++程序的内存开辟

    细心地我们会发现这个图怎么跟上面的不一样，其实这里的栈对应的就是栈区，存放局部变量和函数的形参等；堆对应的就是堆区，存放的是动态内存开辟（malloc、calloc、realloc）；数据段对应的就是静态区，存放的是静态变量和全局变量。

    C/C++程序内存分配的几个区域：
    1. 栈区（stack）：在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。 栈区主要存放运行函数而分配的局部变量、函数参数、返回数据、返回地址等。
    2. 堆区（heap）：一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收 。分配方式类似于链表。
    3. 数据段（静态区）（static）存放全局变量、静态数据。程序结束后由系统释放。
    4. 代码段：存放函数体（类成员函数和全局函数）的二进制代码

    通过上图我们也能更好的理解static关键字修饰局部变量 

    实际上普通的局部变量是在栈区分配空间的，栈区的特点是在上面创建的变量出了作用域就销毁。但是被static修饰的变量存放在数据段（静态区），数据段的特点是在上面创建的变量，直到程序结束才销毁所以生命周期变长 

    五、柔性数组 

    5.1柔性数组概念 

    柔性数组（flexible array） 

    C99 中，结构中的最后一个元素允许是未知大小的数组，这就叫做『柔性数组』成员。  

    举个例子 

    1. {
    2. 	int i;
    3. 	int a[0];//柔性数组成员
    4. }type_a;

     有些编译器会报错无法编译可以改成：

    1. typedef struct st_type
    2. {
    3. 	int i;
    4. 	int a[];//柔性数组成员
    5. }type_a;

    注意:

    柔性数组成员前面必须至少包含一个其他成员 

    5.2柔性数组的特点 

    • 结构中的柔性数组成员前面必须至少一个其他成员。
    • sizeof 返回的这种结构大小不包括柔性数组的内存。
    • 包含柔性数组成员的结构用malloc ()函数进行内存的动态分配，并且分配的内存应该大于结构的大小，以适应柔性数组的预期大小。
    1. typedef struct st_type
    2. {
    3. 	int i;
    4. 	int a[0];//柔性数组成员
    5. }type_a;
    6.  
    7. int main()
    8. {
    9. 	printf("%d ",sizeof(type_a));
    10. 	return 0;
    11. }

     我们可以看到sizeof 返回的这种结构大小不包括柔性数组的内存

    5.3柔性数组的使用 

     使用时我们要记住包含柔性数组成员的结构用malloc ()函数进行内存的动态分配，并且分配的内存应该大于结构的大小，以适应柔性数组的预期大小。

    1. struct S
    2. {
    3. 	int n;
    4. 	char c;
    5. 	int arr[0];//柔性数组成员
    6. };
    7.  
    8. int main()
    9. {
    10. 	struct S* ps = (struct S*)malloc(sizeof(struct S) + 10 * sizeof(int));
    11. 	if (ps == NULL)
    12. 	{
    13. 		printf("%s\n", strerror(errno));
    14. 	}
    15.  
    16. 	//使用
    17. 	ps->n = 100;
    18. 	printf("ps->n = %d\n", ps->n);
    19.  
    20. 	ps->c = 'a';
    21. 	printf("ps->c = %c\n", ps->c);
    22.  
    23. 	int i = 0;
    24. 	for (i = 0;i < 10;i++)
    25. 	{
    26. 		ps->arr[i] = i;
    27. 	}
    28. 	for (i = 0;i < 10;i++)
    29. 	{
    30. 		printf("%d ", ps->arr[i]);
    31. 	}
    32.  
    33. 	free(ps);
    34. 	ps = NULL;
    35.  
    36. }

     柔性数组成员arr，相当于获得了10个整型元素的连续空间

    5.4柔性数组的优势 

    1. struct S
    2. {
    3. 	int n;
    4. 	char c;
    5. 	int arr[0];//柔性数组成员
    6. };
    7.  
    8. int main()
    9. {
    10. 	struct S* ps = (struct S*)malloc(sizeof(struct S) + 10 * sizeof(int));
    11. 	if (ps == NULL)
    12. 	{
    13. 		printf("%s\n", strerror(errno));
    14. 	}
    15.  
    16. 	//使用
    17. 	ps->n = 100;
    18. 	printf("ps->n = %d\n", ps->n);
    19.  
    20. 	ps->c = 'a';
    21. 	printf("ps->c = %c\n", ps->c);
    22.  
    23. 	int i = 0;
    24. 	for (i = 0;i < 10;i++)
    25. 	{
    26. 		ps->arr[i] = i;
    27. 	}
    28. 	for (i = 0;i < 10;i++)
    29. 	{
    30. 		printf("%d ", ps->arr[i]);
    31. 	}
    32.  
    33. 	free(ps);
    34. 	ps = NULL;
    35.  
    36. }

     向上面一样使用柔性数组，有两个好处

    1.方便内存释放

    如果我们的代码是在一个给别人用的函数中，你在里面做了二次内存分配，并把整个结构体返回给用户。用户调用free可以释放结构体，但是用户并不知道这个结构体内的成员也需要free，所以你不能指望用户来发现这个事。所以，如果我们把结构体的内存以及其成员要的内存一次性分配好了，并返回给用户一个结构体指针，用户做一次free就可以把所有的内存也给释放掉

    2.有利于提高访问速度

    连续的内存有益于提高访问速度，也有益于减少内存碎片。

    看到最后这里，如果觉得本文还不错，希望可以点个赞哦！！！如有不对之处，也欢迎大家给我留言交流！！！❥(^_-) 

     

  • 相关阅读:
    线程“八锁“ synchronized到底是对哪个对象加锁?
    多学科融合
    【JVM】第三篇 JVM对象创建与内存分配机制深度剖析
    Hadoop3.x 三大组件详解
    mathtype符号显示不全的问题
    【剑指Offer】58-Ⅱ.左旋转字符串
    vscode软件安装包下载安装教程
    Leetcode刷题-(16~20)-Java+Python+JavaScript
    LeetCode题解：7. 整数反转，迭代，JavaScript，详细注释
    git中 gitignore 忽略文件操作
  • 原文地址：https://blog.csdn.net/wangjie0517/article/details/134465210