【动态内存管理】-关于动态内存你只知道四个函数是不够的，这里还有题目教你怎么正确使用函数，还不进来看看？？

🎇作者：小树苗渴望变成参天大树
💦作者宣言：认真写好每一篇博客
💢 作者gitee：link

如 果 你 喜 欢 作 者 的 文 章 ，就 给 作 者 点 点 关 注 吧！

---

🎉前言

各位友友们大家好，我们又见面了，今天博主又来更新新的知识点了，相信大家已经把我之前写的博客都学习到位了，并且已经熟练的使用了，那我们今天就可以放心的学习新的知识了，我们今天所讲的内容是关于动态内存开辟，让我们原来静态固定的空间变得活灵活现，不在受限制，我们可以根据我们的需要来开辟想要的空间大小，这样即不会空间大小不够，也不会造成浪费，那我们就一起进入关于动态内存开辟的世界吧！！！

本章重点
1.为什么存在动态内存分配
2.动态内存函数的介绍
malloc
free
calloc
realloc
3.常见的动态内存错误
4.几个经典的笔试题
5.柔性数组

---

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

我们已经掌握的内存开辟方式有：

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

但是上述的开辟空间的方式有两个特点：

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

但是对于空间的需求，不仅仅是上述的情况。有时候我们需要的空间大小在程序运行的时候才能知道，那数组的编译时开辟空间的方式就不能满足了。这时候就只能试试动态存开辟了。

✨二、 动态内存函数的介绍

我们可以通过这些函数来实现动态内存开辟的目的

2.1malloc和free

malloc和free都声明在 stdlib.h 头文件中。

C语言提供了一个动态内存开辟的函数：malloc

void* malloc (size_t size);//参数的单位是字节，因为这个函数在设计的时候不知道你会给什么类型的元素开辟空间所以返回类型用void*

这个函数向内存申请一块连续可用的空间，并返回指向这块空间的指针。（可以想象成开辟的一块数组然后把数组起始地址返回）
如果开辟成功，则返回一个指向开辟好空间的指针。
如果开辟失败，则返回一个NULL指针，因此malloc的返回值一定要做检查。
返回值的类型是 void* ，所以malloc函数并不知道开辟空间的类型，具体在使用的时候使用者自己来决定。
如果参数 size 为0，malloc的行为是标准是未定义的，取决于编译器。（想象一下开辟0个字节的空间也没有什么意义）

我们来看例子：

#include<errno.h>
int main()
{
	int* p = (int*)malloc(40);//申请40个字节的空间，用来存放10个整型，用p指针来接收malloc的返回值，需要强制类型转换一下。
	if (p == NULL)//开辟失败的情况
	{
		printf("%s", strerror(errno));//用来检查错误的
	}
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*(p + i) = i+1;//放数据的
	}
	for (i = 0; i < 10; i++)
	{
		printf("%d ", *(p + i));//打印数据的
	}
	return 0;
}

我们用调试的方式来看看：

我们可以看到malloc函数给我们开辟了40个字节的空间，让我们存放下来40个整型

但是我们这个代码是不正确的，我们使用这些动态内存开辟函数我们实际是在堆区上，我们来通过一个图大致了解内存分布

我们手动在堆区开辟空间就要在使用完成后就要手动把空间还回去，不然会出现内存泄漏的问题，后面会详细介绍，那为什么刚才程序没有问题呢？？原因是我们程序在结束的时候，这块空间被操作系统自动回收了，所以没有出现问题，那如果程序是一直运行的状态，那我们使用完不归还是不是就一直占用那块空间，造成内存空间浪费。所以我们要在使用完释放开辟的空间

那我们应该怎么释放呢？？c语言提供一个函数是：free

void free (void* ptr);

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

我们一定是把刚才开辟空间的起始位置传给free,要是接收起始卫视的指针发生变化，那就是部分释放，释放不完全，会出现问题。如果使用的时候比较要改变起始位置，那就提前用一个新指针来保存这个起始位置。

我们来看看释放后的空间会发生什么变化：

我们看到释放后的地址立马就没有了，但代码这样还没有完全对：

我们看到释放后p里面存放的任然是刚才那一块空间的地址编号，这样有人大胆的继续对p进行使用，就会出现非法访问，因为free没有主动置空的功能，所以我们要手动置为空指针，所以刚才代码正确的使用方式应该如下所示：

#include<errno.h>
int main()
{
	int* p = (int*)malloc(40);//申请40个字节的空间，用来存放10个整型
	if (p == NULL)
	{
		printf("%s", strerror(errno));
	}
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*(p + i) = i+1;
	}
	for (i = 0; i < 10; i++)
	{
		printf("%d ", *(p + i));
	}
	free(p);
	p = NULL;
	return 0;
}

这样别人就不会在通过这个指针访问到已经换回去的地址空间了。

我们来看一下开辟失败的案例：

这个时候就会体会到判断返回时候是否为空的重要性了，所以使用这些动态内存开辟函数的时候都需要进行返回值的判断

2.2calloc

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

void* calloc (size_t num, size_t size);

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

我们来看一个例子：

#include <stdio.h>
#include <stdlib.h>
int main()
{
 int *p = (int*)calloc(10, sizeof(int));
 if(NULL != p)
 {
 //使用空间
 }
 free(p);
 p = NULL;
 return 0;
}

我们可以看到malloc和calloc之间的差别，其余的释放和置空都是一样的

所以如何我们对申请的内存空间的内容要求初始化，那么可以很方便的使用calloc函数来完成任务。

2.3realloc

我们在动态开辟空间的时候，可能空间也不太够，这时候就需要一个可以对动态开辟的空间扩容，变成我们想要的空间大小，这时候就有了realloc

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

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

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

情况1：

情况2：

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

那我们可不可以直接这样写

int*p=(int*)malloc(40);
p=(int*)realloc(p,80);

直接把开辟好的空间给原先创建好的指针变量p就行了，反正最后返会回来的地址还是要赋给P,这种对于情况1，2来说结果没有错，但是这么些风险高，万一出现情况3开辟失败呢？那返回的就是NULL，如果用原来的指针直接接收，不但没有起到扩容的目的，还把之前的数据都变成了NULL，把数据丢失了

所以正确的用法应该是：
创建一个临时指针先保存realloc的返回值，然后判断是否为空，在考虑要不要复制给原指针变量。

int main()
{
	int*p = (int*)malloc(5 * sizeof(int));
	if(NULL == p)
	{
		perror("malloc");
		return 1;
	}
	//使用
	int i = 0;
	for (i = 0; i < 5; i++)
	{
		*(p + i) = 1;
	}
	//不够了，增加5个整型的空间
	int* ptr = (int*)realloc(p, 1000*sizeof(int));
	if (ptr != NULL)
	{
		p = ptr;
		ptr = NULL;
	}
	//继续使用空间
	for (i = 0; i < 10; i++)
	{
		printf("%d ", *(p + i));
	}

	//释放空间
	free(p);
	p = NULL;

	return 0;
}

补充一个小的知识点，如果把realloc传一个NULL过去，那么此时realloc的功能和malloc一样的，大家可以自己下去尝试一下

🧨三、常见的动态内存错误

3.1 对NULL指针的解引用操作

void test()
{
 int *p = (int *)malloc(INT_MAX/4);
 *p = 20;//如果p的值是NULL，就会有问题
 free(p);
}

会出现开辟失败的情况，这样malloc就会返回NULL指针，对NULL进行解引用就会出现错误

那我们怎么去避免这个情况呢？
每次申请空间后，返回的指针进行判断后在使用。

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

void test()
{
 int i = 0;
 int *p = (int *)malloc(10*sizeof(int));
 if(NULL == p)
 {
 exit(EXIT_FAILURE);
 }
 for(i=0; i<=10; i++)
 {
 *(p+i) = i;//当i是10的时候越界访问
 }
 free(p);
}

你只开辟了十个整型的空间给你使用，然后你访问了后面不属于你使用空间，就会出现越界访问

怎么去避免这样的情况??
对循环的终止条件和开辟的空间进行一个比较看看有没有越界

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

void test()
{
 int a = 10;
 int *p = &a;
 free(p);//ok?
}

free只会释放了在褪去开辟的空间，而局部变量的空间是在栈区开辟的，所以这样释放会出现错误

怎么去避免这样的问题呢？？
对释放的指针往上面程序找找是不是动态开辟出来的地址，不要直接释放，回头查看一下。

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

void test()
{
 int *p = (int *)malloc(100);
 p++;
 free(p);//p不再指向动态内存的起始位置
}

我们释放开辟的空间必须从起始位置开始释放，如果从中间位置释放，只会释放后面的空间，前面的空间就没有释放掉，如果必须要改变记录起始位置的指针，那就提前使用哟个新的指针保存一份，在进行使用。

怎么解决这样的问题？？
在？需要改变保存起始位置指针的时候，要养成先创建一个临时指针变量来保存起始位置地址

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

void test()
{
 int *p = (int *)malloc(100);
 free(p);
 free(p);//重复释放
}

这样释放会出现错误，因为第一次free§将空间还给了操作系统，使用权限就不再是我们用户自己了，但是pl里面还是保存了刚才开辟的地址，在进行第二次释放，相当于对刚才那块空间又进行了释放操作，既然第一释放后，使用权限就已经不是你了，那你在释放操作这个指针的时候就会出现错误，我们在两次free中间加一个置空操作就行了，free(NULL)是屋顶一的，不做任何操作。

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

也叫内存一直被占用

void test()
{
 int *p = (int *)malloc(100);
 if(NULL != p)
 {
 *p = 20;
 }
}
int main()
{
 test();
 while(1);
}

我们看到在函数内存动态开辟了空间，出了函数体，保存开辟地址的指针变量p就会被销毁，导致了，想释放都释放不了的情况，那么这个开辟的空间在程序结束之前一直都还给不了操作系统，这个程序又是一个死循环，循环一次就会申请一块i地址，知道内存空间被消耗完。但是现在的操作系统有保护机制，到一定的程度就不在给你分配空间了

那我们对于这个代码应该怎么去修改呢？

解决1：

void test()
{
 int *p = (int *)malloc(100);
 if(NULL != p)
 {
 *p = 20;
 }
free(p);
p=NULL:

解决2：

int* test()
{
 int *p = (int *)malloc(100);
 if(NULL != p)
 {
 *p = 20;
 }
 return p;
}
int main()
{
 int *ptr=test();
 free(ptr);
 ptr=NULL:
 while(1);
}

所以我们必须让malloc和free成对出现，并且两个都可以执行到，下面这个代码都不行

void test()
{
 int *p = (int *)malloc(100);
 if(NULL != p)
 {
 *p = 20;
 }
 if(1)
 {
 return NULL;
 ]
free(p);
p=NULL:

这个free根本没有机会执行。所以我们在些这样类型的代码一定要注意犯这样的错误，==以后我们在企业里面，有大型服务器，程序都是一直运行的不能停下来，那我们要是出现了上面那样的问题，需要停下来检查，这时候就会影响公司的利益，后果很严重。

💖四、几个经典的笔试题

4.1 题目1：

void GetMemory(char *p)
{
 p = (char *)malloc(100);
}
void Test(void)
{
 char *str = NULL;
 GetMemory(str);
 strcpy(str, "hello world");
 printf(str);
}

这个程序会直接报错，让我们看一下原因：

解释小的知识点：

在我们印象中，输出出字符串需要用puts();函数，printf应该使用%s进行打印。那下面这种情况是怎么回事呢？？

printf(str);
printf("hehe");

我们看到代码二是我们常见的，其实printf里面放的是这个字符串的起始地址，那么代码1，str表示的也是字符串的起始地址，表达的意思是一样的，==那我们为什么还要有%s呢？？原因是printf布置就打印一种形式及的数据，所以需要%s.==相信这个小的知识点能帮助到你

4.2 题目2：

char *GetMemory(void)
{
 char p[] = "hello world";
 return p;
}
void Test(void)
{
 char *str = NULL;
 str = GetMemory();
 printf(str);
}

程序可以运行，出来的是一些随机值：

我们来一个相似的例子：

int* GetMemory(void)
{
	int a = 10;
	return &a;
}
void Test(void)
{
	int* p = GetMemory();
	printf("%d", *p);
}
int main()
{
	Test();
	return 0;
}

我们看到依旧运行出来了10：

补充理解方式：

我们不管是在释放空间还是销毁变量把空间还回去，只是把使用权限还回去了，之前的数据还是在的，如果没有别人使用这块空间，下次如果你突然有了这块空间的使用权限，你还是可以看到你们的数据，前提是在一次程序结束之前。希望这个立即可以帮助你更好的理解上面两个代码。

4.3 题目3：

void GetMemory(char **p, int num)
{
 *p = (char *)malloc(num);
}
void Test(void)
{
 char *str = NULL;
 GetMemory(&str, 100);
 strcpy(str, "hello");
 printf(str);
}

这个题目的错误就很明显了，我们没有对动态开辟的空间进行释放，修改如下：

void GetMemory(char **p, int num)
{
 *p = (char *)malloc(num);
}
void Test(void)
{
 char *str = NULL;
 GetMemory(&str, 100);
 strcpy(str, "hello");
 printf(str);
}
free(str);//记得释放
str=NULL;

4.4 题目4：

void Test(void)
{
 char *str = (char *) malloc(100);
 strcpy(str, "hello");
 free(str);
 if(str != NULL)
 {
 strcpy(str, "world");
 printf(str);
 }
}

这个题目就是对开辟的空间进行了非法访问，因为已经释放了，使用权限不是我们了，在进行操作修改，就会出现非法访问
我们有两种修改方式：

我们选择第一种，原因是，这个题目想表达的意思就是说对释放后的空间进行非法访问，如果是第二种，那么if就显得优点多余，应该在上面就应该进行判断了，而不是在下面判断，所以我觉得使用第一种修该方式比较好。

通过上面四个题目，我们来总结一点东西，也就是我们接下来要讲的知识点

🎄五、 C/C++程序的内存开辟

C/C++程序内存分配的几个区域：

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

有了这幅图，我们就可以更好的理解在《C语言初识》中讲的static关键字修饰局部变量的例子了。
实际上普通的局部变量是在栈区分配空间的，栈区的特点是在上面创建的变量出了作用域就销毁。但是被static修饰的变量存放在数据段（静态区），数据段的特点是在上面创建的变量，直到程序结束才销毁所以生命周期变长。

💥六、柔性数组

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

例如：

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

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

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

6.1 柔性数组的特点：

一、结构中的柔性数组成员前面必须至少一个其他成员。
二、sizeof 返回的这种结构大小不包括柔性数组的内存。
三、包含柔性数组成员的结构用malloc ()函数进行内存的动态分配，并且分配的内存应该大于结构的大小，以适应柔性数组的预期大小。

例如：

//code1
typedef struct st_type
{
 int i;
 int a[0];//柔性数组成员
}type_a;
printf("%d\n", sizeof(type_a));//输出的是4

因为结构体大小不包括柔性数组的大小，所以我们在柔性数组前面至少有一个其他成员是非常有必要的，不然没法分配空间了

6.2 柔性数组的使用

//代码1
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;
}
free(p);

这样柔性数组成员a，相当于获得了100个整型元素的连续空间。

6.3 柔性数组的优势

上述的代码也可以修改为：

//代码2
typedef struct st_type
{
 int i;
  int *p_a;
}type_a;
type_a *p = (type_a *)malloc(sizeof(type_a));
p->i = 100;
p->p_a = (int *)malloc(p->i*sizeof(int));
//业务处理
for(i=0; i<100; i++)
{
 p->p_a[i] = i;
}
//释放空间
free(p->p_a);//必须先释放柔性数组，因为柔性数组在结构体内部，先释放结构体，就找不到柔性数组了
p->p_a = NULL;
free(p);
p = NULL;

我们来看看代码1和代码2的区别：

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

第二个好处是：这样有利于访问速度.
连续的内存有益于提高访问速度，也有益于减少内存碎片。（其实，我个人觉得也没多高了，反正你跑不了要用做偏移量的加法来寻址）

内存碎片就是，我们使用一块空间，呢一块空间就是一个内存碎片，我们malloc越多，碎片就越多，如果多个malloc,只需要用一个malloc就可以完成，那这样就减少内存碎片，提高内存空间利用率，但是也提高不了多少，因为我们还创建了好多变量了

我们柔性数组不是说你必须用，要会，想用的时候可以用一下，作为一个知识点拓展一下。

💨七、总结

相新今天学了动态内存管理，我们就可以自己为我们的数据开辟想要的空间了，接下来作者会更新关于通讯录的动态内存管理版本，希望各位读者都可以来阅读，学习到知识，今天我们就说到这里吧，我们下篇再见。