前言
1.为什么存在动态内存分配
2.动态内存函数的介绍
- 2.1malloc函数和free函数
- 2.2calloc函数
- 2.3realloc函数
3.常见的动态内存错误
- 3.1对NULL指针的解引用操作
- 3.2对动态开辟空间的越界访问
- 3.3对非动态内存开辟的内存使用free释放
- 3.4使用free释放一块动态内存的一部分
- 3.5对同一块动态内存多次释放
- 3.6动态内存忘记释放（内存泄漏）
4.经典的笔试题目
- 4.1题目1：
- 4.2题目2：
- 4.3题目3：
- 4.4题目4：
5.C/C++程序的内存开辟
6.柔性数组
- 6.1柔性数组的特点：
- 6.2柔性数组的使用
- 6.3柔性数组的优势
总结

前言

在前面的学习中，我们使用变量都需要操作系统分配内存空间，但往往我们使用变量的内存较小，而操作系统为分配的空间较大，会造成内存浪费。那我们能不能自己为变量开辟自己指定的内存空间的呢？答案是：可以。接下来将和大家一起学习动态内存分配的函数！🎠🎠🎠

1.为什么存在动态内存分配

目前我们掌握得的内存开辟方式有：

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

但是上述的开辟空间的方式有两个特点：
1.空间开辟大小是固定的。
2.数组在申明的时候，必须指定数组的长度，它所需要的内存在编译时分配。
但是对于空间的需求，不仅仅是上述的情况，有时候我们需要的空间的大小直到程序运行的时候才能知道，到数组的编译时才开辟空间的方式就不能满足了，这时候让我们试试动态内存开辟，首先我们须知动态内存开辟发生在堆区。
在这里插入图片描述

2.动态内存函数的介绍

2.1malloc函数和free函数

malloc函数
在这里插入图片描述
malloc函数的函数原型为：

void* malloc(size_t size);

头文件：

#include<stdlib.h>

参数： size为内存块的大小，单位为字节，size_t为无符号整型。
函数介绍：
①这个函数向内存申请一块连续可用的内存空间，并返回指向这块空间的指针，如果开辟成功，则返回一个指向开辟好空间的指针；如果开辟失败，则返回一个NULL指针，因此malloc的返回值一定要做类型检查。
②返回值的类型是void*，所以malloc函数并不知道开辟空间得到类型，具体在使用的时候使用者自己来决定。
③如果参数为0，malloc的行为是标准未定义的，取决于编译器。
④malloc函数开辟的内存空间的内容未初始化，内容的值是不确定的。

我们程序员使用内存分配的函数主动向操作系统申请的空间，那么使用完之后也应该主动还给操作系统，避免申请的空间一直闲置造成空间浪费。C语言提供了另外一个函数free,专门用来做动态内存的释放和回收的，让我们一起认识一下吧！

free函数：
在这里插入图片描述
free函数的函数原型为：

void free(void* ptr);

头文件：

#include<stdlib.h>

参数：
ptr：是指向之前分配给malloc、calloc、realloc函数的内存块的指针。
函数介绍:
①free函数释放之前操作系统分配给malloc、calloc、realloc函数的内存块，即将该内存块还给操作系统让其重新分配。
②如果参数ptr指向的空间不是动态开辟的，那free函数的行为是未定义的。
③如果参数ptr是空指针，则函数什么事情都不做。
（注意：此函数不会更改ptr本身的值，因此它仍然指向相同的（无效的）位置，所以一定要将ptr置空）

malloc函数和free函数的使用案例：

#include<stdio.h>
#include<stdlib.h>
int main()
{
	int num = 0;
	printf("请输入所要开辟的内存字节数:>");
	scanf("%d", &num);
	int* ptr = NULL;
	ptr=(int*)malloc(num * sizeof(int));
	if (NULL != ptr)//判断ptr指针是否为空
	{
		int i = 0;
		for (i = 0; i < num; i++)
		{
			*(ptr + i) = i;
			printf("%d ", i);
		}
	}
	free(ptr);//释放ptr所指向的动态内存
	ptr = NULL;//一定要置空
	return 0;
}

free函数执行之前：
在这里插入图片描述
free函数执行之后： 😲😲😲

代码调试、运行的结果：

解释： 从上面代码调试的结果可以看出：①malloc函数分配的空间没有初始化，里面存放的是随机值；②free函数执行后把开辟的动态内存空间还给操作系统；③free函数执行之前和执行之后，指针变量ptr没有变为空指针，成为了野指针，如果再次使用会造成非法访问，一定要在free函数释放完后，将指针变量ptr置空。

2.2calloc函数

C语言还提供了一个函数叫calloc，也用来动态内存分配。
原型如下：

	void* collac(size_t num, size_t size);

头文件：

	#include<stdlib.h>

参数：
num:要分配的元素个数
size:为每个元素的大小
size_t为无符号整型
函数介绍：
①函数的功能是为num个大小为size的元素开辟一块空间，并且把空间的每个字节初始化为0。
②与函数malloc的区别只在于calloc会在返回地址之前把申请的空间的每个字节初始化为0。
③如果num的大小为0，返回值取决于编译器（可能是空指针），但返回的值不应该取消被引用。

calloc函数的使用案例：

#include<stdio.h>
#include<stdlib.h>
int main()
{
	int num = 0;
	printf("请输入所要开辟内存的元素个数:>");
	scanf("%d", &num);
	int* ptr = NULL;
	ptr = calloc(num, sizeof(int));
	if (NULL != ptr)
	{
		int i = 0;
		for (i = 0; i < num; i++)
		{
			*(ptr + i) = i;
			printf("%d ", *(ptr + i));
		}
	}
	free(ptr);//释放内存空间
	ptr = NULL;//指针置空
	return 0;
}

代码调试、运行的结果为：
在这里插入图片描述

解释： 从上面的代码中可以看出：①与malloc函数相比，calloc函数的使用形式相似（两个参数，但最终开辟的空间都以字节单位），使用calloc函数开辟的动态内存空间会被初始化为0；②由于malloc函数动态开辟的内存空间没有初始化，效率更高一些；calloc函数动态内存开辟的空间初始化为0，调试观察会更方便，用哪一个开辟动态内存空间都可以。

2.3realloc函数

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

函数的原型如下：

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

头文件:

#include<stdlib.h>

参数：
ptr：为调整的内存地址，如果为NULL,这种情况下会分配一块新的内存空间（就像函数调用malloc函数一样）
size：为调整之后的新大小
函数介绍:
①函数在调整原内存空间的大小的基础上，还会将原来内存中的数据移动到新的空间，返回值为调整之后的内存起始位置。
②如果ptr是空指针，realloc函数会像malloc函数一样，分配一块新的内存块，并返回一个指向开头的空指针。
③如果size的大小为0，之前ptr指向的内存空间被释放，就像调用free函数一样，并返回一个空指针（C90\C99\C11标准）
④realloc在调整内存空间大小存在两种情况：

情况1：原有空间之后有足够大的空间，直接在后面追加新的空间，返回旧的起始地址。
情况2：原有空间没有足够大的空间，需要重新开辟新的空间，返回新的起始地址。

情况1：
当是情况1的时候，要扩展内存就直接在原有内存之后追加空间，原来的空间的数据不发生变化，同时旧的起始地址。
情况2：
当是情况2的时候，原空间之后没有足够多的空间时，realloc函数会在堆空间上另找一个合适大小的空间大小来使用，把旧的内存空间的数据，拷贝到新空间前面的位置，并且把旧的内存空间释放掉，同时返回一个新的起始地址。

代码1：

#include<stdio.h>
#include<stdlib.h>
int main()
{
	int* ptr = (int*)malloc(40);
	if (ptr != NULL)
	{
		int i = 0;
		for (i = 0; i < 10; i++)
		{
			*(ptr + i) = i;
			printf("%d ", *(ptr + i));
		}
	}
	else
	{
		exit(EXIT_FAILURE);
	}
	ptr = (int*)realloc(ptr, 1000);
	free(ptr);
	ptr = NULL;
	return 0;
}

代码运行的结果为：
在这里插入图片描述

代码2：

#include<stdio.h>
#include<stdlib.h>
int main()
{
	int* ptr = (int*)malloc(40);
	if (ptr != NULL)
	{
		int i = 0;
		for (i = 0; i < 10; i++)
		{
			*(ptr + i) = i;
			printf("%d ", *(ptr + i));
		}
	}
	else
	{
		exit(EXIT_FAILURE);
	}
	int* p = NULL;
	p = (int*)realloc(ptr, 1000);
	if (NULL != p)
	{
		ptr = p;
		ptr=NULL;
	}
	free(ptr);
	ptr = NULL;
	return 0;
}

代码运行的结果为：
在这里插入图片描述

解释：

代码1中用原来的指针接收，代码2用新的指针接收，虽然程序运行结果都一样，但是但是代码1存在问题（警告）。realloc函数开辟新的空间失败，会返回一个空指针，但是原来指针变量ptr指向的内存空间不会释放并且仍然有效。如果用旧的指针ptr接收，那么realloc函数开辟失败时ptr指针置空，程序将无法找到malloc函数开辟的内存块，导致原始数据丢失；如果用新的指针接收，就算realloc函数开辟失败了，也不至于找不到原来内存空间的起始地址。

总结： 使用realloc函数开辟新的空间，返回的地址用新的指针接收。😾😾😾

3.常见的动态内存错误

3.1对NULL指针的解引用操作

#include<stdio.h>
#include<stdlib.h>
void test()
{
	int* p = (int*)malloc(100);
	*p = 20;//如果p为空指针就会有问题
	free(p);
	p = NULL;
}
int main()
{
	test();
	return 0;
}

代码运行的结果：
在这里插入图片描述

解释： 在使用对指针变量p解引用之前，没有判断指针变量是否为空指针，会造成非法访问，建议大家使用if语句进行判断或者assert断言。

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

#include<stdio.h>
#include<stdlib.h>
int main()
{
	int i = 0;
	int* p = (int*)malloc(10 * sizeof(int));
	if (NULL != p)
	{
		for (i = 0; i <= 10; i++)
		{
			*(p + i) = i;
			printf("%d ", *(p + i));
			//当i是10的时候越界访问
		}
	}
	free(p);
	p = NULL;
}

代码运行的结果为：
在这里插入图片描述

解释： 该代码会对动态内存开辟的空间进行非法访问，大家应注意数组越界访问的问题。

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

#include<stdio.h>
#include<stdlib.h>
int main()
{
	int a = 10;
	int* p = &a;
	free(p);//不可以
	return 0;
}

代码运行的结果为：
在这里插入图片描述

解释： 局部变量存放在栈区，而malloc\calloc\realloc\free函数操作的位置为堆区；如果不是malloc\calloc\realloc函数开辟的动态内存开辟的空间，不能使用free函数进行释放。

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

#include<stdio.h>
#include<stdlib.h>
int main()
{
	int* p = (int*)malloc(100);
	p++;
	free(p);//p不再指向动态内存开辟的起始位置
	p = NULL;
	return 0;
}

代码运行的结果为：
在这里插入图片描述

解释： malloc函数返回开辟动态内存的起始地址给指针变量p，指针变量p++后，指针变量p不再指向开辟动态内存空间的起始地址，然后用free函数进行释放，会造成动态内存空间的不完全释放，会出现问题。

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

eg1：

#include<stdio.h>
#include<stdlib.h>
int main()
{
	int* p = (int*)malloc(100);
	free(p);
	free(p);//重复释放
	p = NULL;
	return 0;
}

代码运行的结果为：
在这里插入图片描述

解释： 用free函数释放动态内存空间后，再次使用free函数释放已释放的空间，会出现问题。建议用free函数释放动态内存空间后，立即将指针置空，这样再次使用free函数释放的时候，不会出现任何问题，因为free函数里面为空指针，什么事情都不发生。

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

#include<stdio.h>
#include<stdlib.h>
void test()
{
	int* p = (int*)malloc(100);
	if (NULL != p)
	{
		*p = 20;
	}
}
int main()
{
	test();
	while (1);
	return 0;
}

代码运行的结果为：
在这里插入图片描述
eg2:

#include<stdio.h>
int main()
{
	while (1)
	{
		malloc(1);
	}
	return 0;
}

代码调试的结果为：
在这里插入图片描述

解释： ①代码1可以看出，使用完动态内存开辟的空间后没有立即释放，此时运行程序的时候，test的函数栈帧销毁后，p指针变量也会销毁，p指针变量指向的空间便找不到了，也释放不掉，会对内存空间浪费，直到程序运行结束时，才会释放；②代码2运时在任务管理器中的结果可以看出，如果一直用malloc申请空间不释放，会一直消耗内存，此时操作系统会进行限制。
切记： 动态开辟的内存空间一定要释放，并且正确释放。

4.经典的笔试题目

4.1题目1：

请问运行程序会有什么的结果？

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
void GetMemory(char* p)
{
	p = (char*)malloc(100);
}
int main()
{
	char* str = NULL;
	GetMemory(str);
	strcpy(str, "hello world");
	printf(str);
	return 0;
}

代码运行的结果为：
在这里插入图片描述

解析： 运行程序的过程中会出现问题：①main函数中GetMemory（str）的传参属于值传递，GetMemory中p是str的一份临时拷贝，当指针p发生改变的时候并不会影响指针str,此时str仍然为空指针，strcpy进行拷贝的时候，会造成非法访问；②GetMemory函数开辟了动态内存空间忘记释放，会造成内存泄漏。

4.2题目2：

请问运行程序会有什么的结果？

#include<stdio.h>
#include<stdlib.h>
char* GetMemory(void)
{
	char p[] = "hello world";
	return p;
}
int main()
{
	char* str = NULL;
	str=GetMemory();
	if (str != NULL)
	{
		printf(str);
	}
}

代码运行的结果为：
在这里插入图片描述

解释： 程序存在的问题：GetMemory函数栈帧销毁的时候，GetMemory函数的空间已经返回给操作系统，main函数中用指针变量str接收GetMemory函数的返回的局部地址，然后用printf(str)进行打印，会造成非法访问，打印出随机值。

4.3题目3：

//请问运行程序会有什么的结果？
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
void GetMemory(char**p,int num)
{
	*p = (char*)malloc(num);
}
int main()
{
	char* str = NULL;
	GetMemory(&str, 100);
	if (str != NULL)
	{
		strcpy(str, "hello");
		printf(str);
	}
	return 0;
}

代码运行的结果为：
在这里插入图片描述

解释： 程序虽然能正常运行，但是仍然存在的问题：main函数中使用完str指向的动态内存空间后，没有释放，会造成内存泄漏。

4.4题目4：

//请问运行程序会有什么的结果？
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
int main()
{
	char* str = (char*)malloc(100);
	if (str != NULL)
	{
		strcpy(str, "hello");
	}
	free(str);
	if (str != NULL)
	{
		strcpy(str, "world");
		printf(str);
	}
	return 0;
}

代码运行的结果为：
在这里插入图片描述

解释： 程序运行过程中存在的问题：在free函数释放完内存空间之后，str指针变量没有置空，导致后面的语句进行非法访问。

5.C/C++程序的内存开辟

在这里插入图片描述
C/C++程序内存分配的几个区域：

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

总结： 普通局部变量在栈区分配空间，出了作用域就销毁；static修饰的变量存放在数据段（静态区），直到程序结束才销毁，生命周期变长。

6.柔性数组

也许你从来没有听说过柔性数组（flexible array）这个概念，但是确实是存在的。C99中，结构中的最后一个元素允许未知大小的数组，这就叫做柔性数组成员

eg:

typedef struct st_type
{
	int i;
	int a[0];//柔性数组成员
}type_a;

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

typedef struct st_type
{
	int i;
	int a[];//柔性数组成员
}type_a;

6.1柔性数组的特点：

①sizeof返回的这种结构大小不包括柔性数组的内存。

eg:

#include<stdio.h>
typedef struct st_type
{
	int i;
	int a[0];//柔性数组成员
}type_a;
int main()
{
	printf("%d\n", sizeof(type_a));
	return 0;
}

代码运行的结果：
在这里插入图片描述

解释： 从上面代码可以看出，sizeof计算的仅仅是结构体第一个成员（int i）的大小，因为柔性数组的大小未知无法计算。
②结构体的柔性数组成员前面必须至少一个其他成员。

因为柔性数组的大小未知，无法为其分配空间

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

eg:

#include<stdio.h>
typedef struct st_type
{
	int i;
	int a[0];//柔性数组成员
}type_a;
int main()
{
	type_a* p = (type_a*)malloc(sizeof(type_a) + 10 * sizeof(int));
	return 0;
}

解释： 上述代码中10 * sizeof(int)语句就是为柔性数组开辟的预期空间，即柔性数组被我们设置为10个元素的整型大小。

6.2柔性数组的使用

代码1：

//代码1
#include<stdio.h>
typedef struct st_type
{
	int i;
	int a[0];//柔性数组成员
}type_a;
int main()
{
	int i = 0;
	type_a* p = (type_a*)malloc(sizeof(type_a) + 100 * sizeof(int));
	p->i = 100;
	for (i = 0; i < 100; i++)
	{
		p->a[i] = i;
		printf("%d ", p->a[i]);
	}
	free(p);
	p = NULL;
}

代码运行的结果：
在这里插入图片描述
经过malloc函数结构分配内存，柔性数组成员a,相当于获得了100个整型元素的连续空间。

6.3柔性数组的优势

上述的type_a的结构也可以设计为：
代码2：

//代码2
#include<stdio.h>
#include<stdlib.h>
typedef struct st_type
{
	int i;
	int* p_a;
}type_a;
int main()
{
	type_a* p = (type_a*)malloc(sizeof(type_a));
	p->i = 100;
	p->p_a = (int*)malloc(p->i * sizeof(int));
	int i = 0;
	for (i = 0; i < 100; i++)
	{
		p->p_a[i] = i;
		printf("%d ", p->p_a[i]);
	}
	free(p->p_a);
	p->p_a = NULL;
	free(p);
	p = NULL;
}

代码运行结果为：
在这里插入图片描述
上述的代码1和代码2可以完成同样的功能，但是代码1的实现有两个好处：
第一个好处是：

如果我们的代码是一个给别人用的函数，你在里面做了二次分配，并把整个结构体返回给用户。用户调用free可以释放结构体，但是用户并不知道这个结构体内的成员也需要free，所以你不能指望用户来发现这个事情。所以，如果我们把结构体的内存以及其成员要的内存一次性分配好了，并返回给用户一个结构体指针，用户用一次free就可以把所有的内存也释放掉。
第二个好处是：
连续的内存有益于提高访问速度，也有益于内存碎片（做偏移量的加法来寻址）。
总结：
代码1特点：只需要使用malloc函数、free函数各一次，可以提高效率，但是要在特定环境下实现（结构体柔性数组成员放在最后面）；代码2特点：结构体的指针成员可以随意放置，不需要考虑特定环境，但是要使用malloc函数、free函数各两次，且顺序不能错误。

总结

本章我们一起学习了

1.动态内存开辟的函数中

①malloc函数
+② free函数
③calloc函数
④realloc函数
2.常见的动态内存错误
①对NULL指针的解引用
②对动态开辟内存空间的越界访问
③对非动态开辟的内存使用free函数释放
④使用free释放一块动态开辟内存的一部分
⑤对同一块多态内存的多次释放
⑥动态开辟忘记释放（内存泄漏）
3.经典笔试题目
4.C/C++程序的动态开辟
5.柔性数组
①柔性数组的特点
②柔性数组的使用
③柔性数组的优势