在这里插入图片描述

📝个人主页：@Sherry的成长之路
🏠学习社区：Sherry的成长之路（个人社区）
📖专栏链接：C语言进阶
🎯长路漫漫浩浩，万事皆有期待

文章目录

1.动态内存
- 1.1 概述：
- 1.2.动态内存分配的意义：
2.常用的动态内存函数
- 2.1 malloc 和 free：
- - 2.1.1 malloc 函数：
  - 2.1.2 free 函数：
  - 2.1.3 malloc 函数与 free 函数的使用：
- 2.2 calloc 函数：
- 2.3 realloc 函数：
3. 常见动态内存错误
- 3.1 对 NULL 指针的解引用操作
- 3.2 对动态内存空间的越界访问
- 3.3 对非动态内存空间使用 free 函数
- 3.4 使用 free 函数释放动态内存空间的一部分
- 3.5 对同一块动态内存空间多次释放
- 3.6 不释放动态内存空间（内存泄漏）
4. 柔性数组：
- 4.1 柔性数组的特点：
- 4.2 柔性数组的使用：
- 4.3 柔性数组的优势：
5.总结：

1.动态内存

1.1 概述：

在c/c++语言中，所谓动态内存分配，就是指在程序执行的过程中动态地分配或者回收存储空间的分配内存的方法。动态内存分配不像数组等静态内存分配方法那样需要预先分配存储空间，而是由系统根据程序的需要即时分配，且分配的大小就是程序要求的大小。

1.2.动态内存分配的意义：

我们在之前的学习过程中，在使用各种变量与数组等等功能时，都需要从内存中开辟出一片空间用于存放我们的数据，而在之前我们掌握的内存开辟方式有：

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

但是我们最经常时使用的这两种内存空间的开辟方式有一些共同的特点：

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

换句话说，这两种内存开辟方式都是静态内存分配。
但是我们在日常的代码编写和程序使用过程中，对于空间的需求往往不仅限于上述情况。更多的时候我们需要的空间大小只有在在程序运行的时候才能知道。如此，数组等在编译时开辟空间的方式无法满足我们的实际运行需求。于是就需要使用一种更好的内存分配方式进行处理:动态内存分配

2.常用的动态内存函数

2.1 malloc 和 free：

malloc 函数（memory allocate，即内存分配）的作用为向内存的堆区申请空间来存储数据，free 函数的作用为释放使用 malloc 函数向堆区申请的空间，并将空间归还给内存的堆区空间，通过配合使用这两个函数可以从堆区申请（释放）动态内存空间。

2.1.1 malloc 函数：

malloc 函数的使用格式为：

void* malloc (size_t size);

从它的使用格式中我们可以看出，该函数向堆区申请了一块连续的空间，同时返回的是这块空间的指针。

如果开辟成功，则返回一个指向开辟好空间的指针。
如果开辟失败，则返回一个 NULL 指针，故我们在使用时一定要仔细检查 malloc 函数的返回值。
返回值的类型是 void* ，即 malloc 函数并不了解开辟空间的类型，至于空间的具体类型将在使用时由使用者自己决定。
如果参数 size 为 0，则 malloc 函数的行为是标准未定义的，将会取决于编译器。

2.1.2 free 函数：

我们可以看到，free 函数的使用格式为：

void free (void* ptr);

不同的是，与 malloc 函数恰好相反，free函数的作用为释放动态开辟的内存，同时没有返回值：

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

2.1.3 malloc 函数与 free 函数的使用：

关于两个函数的实际使用，我们直接来看下面这段 malloc 函数与 free 函数的使用实例：

#include<stdio.h>
#include<stdlib.h>
int main()
{
	int* ptr = NULL;
	//初始化指针
	ptr = (int*)malloc(40);
	//使用malloc函数动态申请40字节空间
	//同时因为指针ptr类型为int*，而 malloc 函数的返回类型为void*，故使用强制类型转换
	int* p = ptr;
	//在此定义指针p的原因是，在之后的使用中，指针p的指向会发生改变
	//若不对初始指针指向进行保存，将无法释放改变前与改变后之间的空间
	if (p == NULL)
	//mallocc函数在动态空间开辟失败时返回空指针
	//即若此处为空指针，说明动态内存空间申请失败
	{
		perror("malloc");
		//打印malloc函数动态空间申请错误原因，并结束程序
		return 1;
	}
	//没有结束说明指针不为空，动态空间申请成功
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*p = i;
		//循环向动态内存空间中存入数据
		p++;
		//在此处的操作中，指针p的指向发生了改变
	}
	//使用完成后释放动态内存空间：
	free(ptr);
	//指针p指向发生改变，但指针ptr仍指向初始指针
	ptr = NULL;
	//动态内存空间归还后，重新将指针ptr置空
	//动态内存空间已经归还，若不将指针ptr进行置空，指针ptr将变为野指针，指向将不可控，这在程序运行中非常危险
	return 0;
}

对其中几个地方进行强调：

在对指针进行操作前一定要保存指向初始位置的原始指针。
在对指向动态内存空间的指针进行使用前，一定要进行非空判断。
在动态内存空间使用完毕并释放后，一定要将指针进行置空操作。
当程序结束时若动态内存空间没有被释放，将会被操作系统自动回收。
但若程序不结束且申请的动态内存空间持续不归还，动态内存将不会被回收，就会导致内存泄漏问题。

2.2 calloc 函数：

calloc 函数的使用格式为：

void* calloc (size_t num, size_t size);

，calloc 函数的功能是为 num 个大小为 size 的元素开辟一块动态内存空间，并将空间内每个字节都初始化为 0。其使用方式与 malloc 函数无异：

#include<stdio.h>
#include<stdlib.h>
int main()
{
	int* ptr = NULL;
	ptr = (int*)calloc(10, sizeof(int));
	//使用calloc函数动态申请10个int类型大小的空间
	//同时因为指针ptr类型为int*，而calloc函数的返回类型为void*，故使用强制类型转换
	int* p = ptr;
	if (p == NULL)
	{
		perror("calloc");
		return 1;
	}
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*p = i;
		p++;
	}
	free(ptr);
	ptr = NULL;
	return 0;
}

并且实际作用相比较来说，与函数 malloc 的区别仅在于 calloc 函数在返回地址前会把申请的空间内每个字节都初始化为 0 ，其它方面完全相同。

2.3 realloc 函数：

realloc 函数（re - allocate，即重新分配）的作用为重新分配从堆区申请来的动态内存空间的大小。其使用格式为：

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

realloc 函数的出现，使得动态内存管理更加的灵活。例如有些时侯我们觉得前面申请的空间太小了不够用，或者我们会觉得申请的空间过大了太浪费，这个时候我们就可以通过使用 realloc 函数对之前开辟的动态内存空间的大小再次进行合理的调整。正是 realloc 函数才使得动态内存空间真正变得“ 动态 ”起来。

#include<stdio.h>
#include<stdlib.h>
 
int main()
{
	int* ptr = NULL;
	ptr = (int*)malloc(40);
	int* p = ptr;
	if (p == NULL)
	{
		perror("malloc");
		return 1;
	}
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*p = i;
		p++;
	}
	realloc(ptr, 80);
	//空间不够用，重新分配更大的空间
    //将指针ptr指向的空间扩容至80字节
 
	free(ptr);
	PTR = NULL;
	return 0;
}

但哪怕是在成功扩容时，也仍会出现两种情况：当前空间与后相邻空间之间的空间是否足够 realloc 函数进行扩容操作

1.若空间足够，则直接执行扩容操作，并在扩容完成后返回指向起始位置的指针。
2.若空间不够，则将会在堆区中重新寻找合适的空间（足以容纳下扩容后的全部空间），并将原空间内的数据全部拷贝过来，接着释放原空间，并在扩容完成后返回指向新空间起始位置的指针。

但是还有最特殊的情况，即内存堆空间中没有能够容纳整个扩容后的动态内存空间的空间时，将会返回空指针。所以，我们在想要使用扩容后的动态内存空间时，为了避免使用指针内容为空指针而造成的意外错误，在使用之前首先应当对 realloc 函数返回的指针进行非空判断，之后再拿来使用：

#include<stdio.h>
#include<stdlib.h>
int main()
{
	int* ptr = NULL;
	ptr = (int*)malloc(40);
	int* PTR = NULL;
	PTR = (int*)realloc(ptr, 80);
	int* p = NULL;
	//空间不够用，重新分配更大的空间
	//将指针ptr指向的空间扩容至80字节
	if (PTR != NULL)
	//使用前进行非空判断，避免出现无法预料的错误
	{
		p = PTR;
	}
	//判断非空，即扩容成功，开始使用：
	int i = 0;
	for (i = 0; i < 20; i++)
	{
		*p = i;
		p++;
	}
	free(PTR);
	PTR = NULL;
	return 0;
}

3. 常见动态内存错误

3.1 对 NULL 指针的解引用操作

int main()
{
	int* p = (int*)malloc(INT_MAX);
	//当尝试开辟的空间过大时，将会导致动态内存开辟失败
	//此时malloc函数将会返回空指针，即此时指针p也是空指针
	*p = 20;
	//没有判断非空就对指针p进行解引用操作，导致产生对空指针进行了解引用操作
	//将会造成内存非法访问的错误
    free(p);
	p = NULL;
	return 0;
}

避免出现此类问题的方法是，在指针使用前对 malloc 等函数的返回值进行非空判断。

3.2 对动态内存空间的越界访问

int main()
{
	int* p = (int*)malloc(10 * sizeof(int));
	if (NULL == p)
	{
		perror("malloc");
		return 1;
	}
	int i = 0;
	for (i = 0; i <= 10; i++)
	{
		*(p + i) = i;
		//当i=10时，将会出现越界访问的错误
	}
	free(p);
	p = NULL;
	return 0;
}

避免此类错误的方式是，在使用时仔细认真的进行内存边界的检查，并选择合适的空间访问范围。

3.3 对非动态内存空间使用 free 函数

int main()
{
	int a = 10;
	//变量a所使用的内存空间不是动态内存空间
	int* p = &a;
	free(p);
	//释放非动态内存空间
    p = NULL;
	return 0;
}

避免此类错误的方式是，在进行空间释放时注意区分静态内存空间与动态内存空间。

3.4 使用 free 函数释放动态内存空间的一部分

int main()
{
	int* p = (int*)malloc(10 * sizeof(int));
	if (p == NULL)
	{
		perror("malloc");
		return 1;
	}
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*p = i;
		p++;
		//此时指针p的指向已经发生变化，不再指向起始位置
	}
	free(p);
	//释放部分动态内存空间
	p = NULL;
	return 0;
}

避免此类错误的方法是，在使用指针前保存好初始指向，并在进行动态内存释放时释放完整的动态内存空间。

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

int main()
{
	int* p = (int*)malloc(10 * sizeof(int));
	free(p);
	//...(在中间又进行了很多其它操作之后，忘记了已经释放过动态内存空间，并进行了重复释放)
	free(p);
	//重复释放动态内存空间
	p = NULL;
	return 0;
}

避免此类问题的方法是，在已经释放过动态内存空间之后，一定要加以注释以提醒自己避免重复释放同一块动态内存空间。

3.6 不释放动态内存空间（内存泄漏）

void test()
{
	int* p = (int*)malloc(10 * sizeof(int));
	if (p != NULL)
	{
		*p = 20;
		//判断非空后进行使用
	}
	//使用后没有释放动态内存空间，在程序终止前该动态内存空间都将无法被释放，将会逐渐消耗计算机系统的内存
}
int main()
{
	test();
	while (1);
	//为了演示内存泄漏，使程序永不终止
	return 0;
}

避免此类问题的方法是，永远记住，使用一个释放一个，使用结束立刻释放。

4. 柔性数组：

或许很多人都未曾听过柔性数组（flexible array）这个概念，但是它又是确实存在的，并且它的存在对于我们进行动态内存管理有着巨大的作用。在 C99 标准中，结构中的最后一个元素的大小允许是未知大小的数组，而我们就将这个未知大小的数组称为柔性数组，并将这个数组成员称为柔性数组成员：

typedef struct A
{
	int a;
	int arr1[0];
	//柔性数组成员
}A;
typedef struct B
{
	int b;
	int arr2[];
	//柔性数组成员
}B;

4.1 柔性数组的特点：

柔性数组主要有以下 3 个特点：
①. 结构中的柔性数组成员前面必须至少存在一个其他成员。
②. sizeof 返回的这种结构大小不包括柔性数组的内存。
③. 包含柔性数组成员的结构用 malloc () 函数进行内存的动态分配，并且分配的内存应该大于结构的大小，以适应柔性数组的预期大小。

定义中我们可以得知，柔性数组只能作为结构的最后一个元素，并且柔性数组的大小是不确定的，因此在结构中，柔性数组之前至少要有一个其它成员的存在。
因为柔性数组的大小是未知的，因此在计算结构大小时，将不会计入柔性数组的大小：

typedef struct test
{
	int i;
	int arr[];
}test;
int main()
{
	test a;
	printf("The size of a is ：%d\n", sizeof(a));
	return 0;
}

例如上述代码的编译运行结果显示，类型 a 的大小为 4 个字节，即只包含成员整形变量 i
因为柔性数组的大小是未知的，因此其大小是动态、可变的，故在给其分配空间时，应当使用 malloc 函数进行动态内存分配。同时因为计算结构大小时没有计入柔性数组的大小，因此分配的内存大小应当大于结构的大小，才能容纳下柔性数组的预期大小：

typedef struct test
{
	int i;
	int arr[];
}test;
 
int main()
{
	test a;
	//定义test类型结构体a
	test* p = (test*)malloc(sizeof(test) + 40);
	//结构的大小为sizeof(test)的大小，故开辟的动态内存大小应当大于该值
	free(p);
	p = NULL;
	return 0;
}

4.2 柔性数组的使用：

typedef struct test
{
	int i;
	int arr[];
}test;
int main()
{
	test a;
	//定义test类型结构体a
	test* p = (test*)malloc(sizeof(test) + 40);
	//malloc函数的返回值为指针类型，故使用结构体指针test*
	//使用malloc函数动态分配空间：test类型结构体的大小(不包含柔性数组) + 40字节
	if (p == NULL)
	{
		perror("malloc");
		//判断动态内存空间是否开辟成功
		return 1;
	}
	//业务处理1：
	p->i = 10;
	int i = 0;
	//给柔性数组元素赋值：
	for (i = 0; i < p->i; i++)
	{
		p->arr[i] = i;
	}
	//打印柔性数组元素：
	for(i=0;i<p->i;i++)
	{
		printf("%d ", p->arr[i]);
	}
	printf("\n");
 
	test* pp = (test*)realloc(p, sizeof(test) + 80);
	//使用realloc函数将结构指针指向的结构a进行扩容
	if (pp == NULL)
	{
		perror("realloc");
		//判断动态内存空间是否扩容成功
		return 1;
	}
	//业务处理2：
	pp->i = 20;
	for (i = 0; i < pp->i; i++)
	{
		pp->arr[i] = i + 9;
	}
	for (i = 0; i < pp->i; i++)
	{
		printf("%d ", pp->arr[i]);
	}
	printf("\n");
	free(pp);
	pp = NULL;
	return 0;
}

在这里插入图片描述
在这个示例中，我们首先定义了 test 类型结构体 a，接着使用了 malloc 函数为结构体 a 与柔性数组分配了动态存储空间；接着在判断非空（动态内存空间分配成功）后给结构体成员 i 与柔性数组 arr 内元素赋值，并进行了打印；再接下来，我们通过使用 realloc 函数将包含柔性数组 arr 的结构体 a 扩容，并在扩容后给结构体内各成员重新赋值并打印；最后释放使用完毕的动态内存空间并将指针置空

4.3 柔性数组的优势：

但是同时我们又发现，我们使用柔性数组的目的在于希望使结构成员的空间变为动态，可大可小，若将其写成指针，由指针成员来指向其它的空间。如下：

typedef struct test
{
	int i;
	int* p;
}test;
int main()
{
	test* ptr = (test*)malloc(sizeof(test));
	if (ptr == NULL)
	{
		perror("malloc");
		return 1;
	}
	ptr->p = (int*)malloc(40);
	if (ptr->p == NULL)
	{
		free(ptr);
		ptr = NULL;
		return 1;
	}
	return 0;
}

我们说，这两种方法都可以达到我们的要求，实现我们的目的，完成同样的功能。
但是使用柔性数组有三个显著的好处：

1.方便内存释放,例如进行了二次空间分配，即使用指针指向了另一块动态内存空间，还有另外一块动态内存空间需要及时进行释放，一旦没有注意，就有可能会造成内存释放不及时，严重时甚至有可能会导致内存泄漏问题的产生。反观使用柔性数组，只需调用一次 free 函数即可完成内存空间的释放。
2.有利于提升访问速度,使用了二次空间分配，则在访问时的寻址过程中就需要花费更多的时间，而如果我们使用了柔性数组，由于开辟的空间是连续的，在寻址时便可以节省一定的时间。
3.有利于减少内存碎片,使用二次内存分配的方式所申请到的空间是不连续的，就会在内存中产生更多的空隙，就会导致内存空间中产生更多的内存碎片，而使用柔性数组所申请的空间是连续的，则作为一个个整体，就可以减少内存碎片的产生了。