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

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

🎉前言

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

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

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

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

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

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

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

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

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

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

2.1malloc和free

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

#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;
}

void free (void* ptr);

#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

void* calloc (size_t num, size_t size);

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

2.3realloc

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

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

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;
}

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

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就可以完成，那这样就减少内存碎片，提高内存空间利用率，但是也提高不了多少，因为我们还创建了好多变量了

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

💨七、总结

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