---

前言（栈区、堆区、静态区）

请耐心看完，看完后就会对内存中的空间划分有了更深刻的认识！

我们知道，任何一个变量的创建都会向内存申请空间用来存放，而在内存中的空间又划分为几个区域、最主要划分为：栈区、堆区、静态区

而我们平常创建变量或者数组，如下：

int a=0;
int arr[1000];

这里的a与arr都是在栈区开辟空间的，而栈区的特点之一就是出了作用域就会自动销毁，所以它们的生命周期只要出了所在的作用域就结束了。因此在栈区上开辟空间的变量一般都是：局部变量、形参这种

而且我们发现，在栈区上开辟空间的一些变量，它们的大小都是固定的，就比如上文的数组arr，它的大小就是固定的4000字节，但是我们可以想一下，有时候在使用它的时候，并不需要这么多的空间，可能仅仅只需要10个整形大小的空间，而后面的990个整形空间都会被浪费掉，着实是可惜呀！

---

那我们不禁美滋滋的会这么想象，会不会存在我们想用多少空间，就开辟多少空间的可能呢？答案是有的！
我们上面提到了内存中还划分有堆区，而堆区的特点之一就是：可以按自己的需求开辟空间，并且该空间出了作用域不会自动销毁，只能人工销毁，这就实现了我们想要的需求。

那么应如何在堆区开辟空间呢？这里就涉及到了以下讲到的几个函数：malloc、realloc、calloc，还有用来释放空间的free

---

可能有人还会疑问，上面的静态区是干嘛的，所谓的静态区，它的特点是：永恒存在、生命周期一直到程序结束所以在静态区开辟空间的变量一般为：常量、const修饰的常变量、全局变量、以及static修饰的静态 全局/局部 变量。

---

动态内存函数

我们上面已经讲过了，动态内存分配是在堆区完成、并且空间是由程序员自己释放，因此切记，malloc、calloc、realloc与free都是成对出现的！

malloc与free

首先是malloc，向内存申请size字节的空间，然后返回该空间的起始地址。

使用演示

#include<stdio.h>
#include<stdlib.h>//头文件
int main()
{
	int* p = (int*)malloc(10*sizeof(int));
	//开辟10个整形大小的空间（40byte），然后用指针p来接收该空间的起始地址
	//因为p是int*类型的，所以将该空间强制类型转换成（int*），保证用来接收的指针类型与开辟空间的类型一致
	if (p == NULL)
	{
		perror("malloc");
		return 1;
	}
	//对空间进行一个判断，假如开辟失败，打印错误，并返回。return 1表示非正常返回、
	//开辟成功正常使用
	//...
	free(p);//使用完一定记得释放！（从哪里申请，从哪里释放,后面会将注意事项）
	p = NULL;//将指针置空
	return 0;
}

这里一定要对p进行判断，因为假如空间开辟失败，p就是一个空指针，后面假如对p进行操作与使用，很可能会出现很大的问题！

calloc与free

calloc与malloc很像，使用也基本相同，只不过它是这样使用的：开辟num个大小为size的空间，并且将空间的每个字节都初始化为0，而malloc开辟的空间里面的值是随机值。

使用演示

#include<stdio.h>
#include<stdlib.h>//头文件
int main()
{
	int* p = (int*)calloc(10,sizof(int));
	//开辟个10个空间，每个空间大小为一个整形大小（一共40byte），然后用指针p来接收该空间的起始地址
	//因为p是int*类型的，所以将该空间强制类型转换成（int*），保证用来接收的指针类型与开辟空间的类型一致
	if (p == NULL)
	{
		perror("calloc");
		return 1;
	}
	//对空间进行一个判断，假如开辟失败，打印错误，并返回。return 1表示非正常返回、
	//开辟成功正常使用
	//...
	free(p);//使用完一定记得释放！（从哪里申请，从哪里释放,后面会将注意事项）
	p = NULL;//将指针置空
	return 0;
}

realloc与free

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

但是会存在原地扩容和异地扩容两种情况

使用演示

#include<stdlib.h>//头文件
#include<stdio.h>

int main()
{
	int* p = (int*)malloc(40);//开辟40byte
	//判断是否开辟成功
	if (p == NULL)
	{
		perror("malloc fail");
		return 1;
	}
	//使用p指向的空间
	for (int i = 0; i < 10; i++)
	{
		*(p + i) = i;
	}
	for (int i = 0; i < 10; i++)
	{
		printf("%d ", *(p + i));
	}
	//0 1 2 3 4 5 6 7 8 9
	//扩容，用ptr接收新空间起始地址
	int* ptr = (int*)realloc(p, 80);
	if (ptr != NULL)
	{
		//扩容成功后，让p指向ptr，ptr置空
		p = ptr;
		ptr = NULL;
	}
		//使用
		for (int i = 0; i < 20; i++)
		{
		*(p + i) = i;
	}
	for (int i = 0; i < 20; i++)
	{
		printf("%d ", *(p + i));
	}
	//使用完释放
	free(p);
	p = NULL;
	return 0;
}

---

常见的动态内存错误

我们在使用动态内存分配时总是难免会犯一些不必要的错误，毕竟人非圣贤，孰能无过，接下来我将列举这些常见的错误，以警示避免！
1、对空指针的解引用
例：

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

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的时候越界访问，error！
 }
 free(p);
}

3、对非动态开辟内存使用free释放
例：

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

4、使用free释放一块动态开辟内存的一部分
例：

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

5、 对同一块动态内存多次释放
例：

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

6、 动态开辟内存忘记释放（内存泄漏）
例:

void test()
{
 int *p = (int *)malloc(100);
 if(NULL != p)
 {
 *p = 20;
 }
 //忘记释放！error！
}
int main()
{
 test();
 while(1);
}

动态开辟的内存空间不使用的时候一定要记得释放！

---

经典笔试题（再见张三）

接下来通过一些经典笔试题的讲解来加深对动态内存分配的理解：
题目一：解释运行Test函数出现的结果

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

分析：

在这里，str首先置空，把str传过去，用指针p来接收，然后p再指向新开辟的空间，再把hello拷贝到该空间，接着打印。
听起来好像没什么毛病，但是我们忽略了以下几点！首先，malloc开辟的空间并没有free，造成内存泄漏，这时最明显的错误！
然后，GetMemory这里只是传址调用，也就是说，p确实指向了那块空间，但是实际上str并没有指向，这里只是把str=NULL的值，传了过去，p=NULL，然后对p进行操作，我们知道，传值调用，形参的改变不会影响实参！所以str仍是NULL，而strcpy一个空指针，就涉及到了对空指针的解引用，ERROR！
这两处错误最为致命！

作为修改，我们可以这样改正：

void GetMemory(char** p)//一级指针的地址用二级指针来接收
{
	*p = (char*)malloc(100);//*p 等价于*&str，等价于str，即str=......
}
void Test(void)
{
	char* str = NULL;
	GetMemory(&str);//传址调用，对形参的修改会影响实参
	strcpy(str, "hello");
	printf(str);
	free(str);//释放
	str = NULL;
}

笔试题二：以下代码运行结果：

#include<stdlib.h>
#include<stdio.h>
#include<string.h>
char* Getmemory()
{
char p[] = “hello world!”;
return p;
}
void test()
{
char* str = NULL;
str = Getmemory();
printf(str);
}
int main()
{
test();
return 0;
}

看起来没什么问题，str来接收Getmemory返回的地址，然后打印，按理来说应该是hello world!，但是，真实结果却是一堆乱码

这是为什么呢？
分析：

在前言那块，讲到了栈区的特点就是出作用域后会自动销毁，我们看这里的p，p是数组名，表示数组首元素的地址，在这里即字符’h‘的地址，然后返回该地址用str来接收，但是！别忘记p是个局部变量，局部变量在栈区开辟空间，出作用域后会自动销毁！也就是说
虽然传给了h所在的地址，但是当它传过去的那一刻，p所在的空间就自动销毁，而str依然记着那块空间，但是此时的那块空间已经不属于p了，这就造成了野指针的访问，谁也不知道那块空间销毁后里面是什么，所以打印乱码。

图解：

张三 and 李四

举个张三与李四的故事来方便大家理解（🤭），张三与李四是一对情侣，这一天，好不容易放假，李四就去酒店开了个房，然后把房间号告诉了李四，然后自己在房间里等他，等啊等，发现张三一直在打lol，还没有过来，就气的也没有告诉张三，就把房间退了，然后房间里现在住着王二麻子和他对象，假如张三再去找李四，确实，他记得房间号码，也能找到位置，但是他不知道房间里已经换人了，此时他不打开房间还好，假如打开的话…（狗头保命🐕）

这里的张三就好比题目里的str，p->酒店房间，p的地址->房间号码，空间销毁之前里面住的是李四，销毁后住的王二麻子。
str虽然能找到p之前指向的空间，但空间里的内容早已换了~

柔性数组

定义

柔性数组这个名词听起来很高大上，但其实并没有什么特殊的，那么它是什么呢？简单来说，就是结构体中的最后一位成员为数组，并且大小未知。
举个栗子：

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

这里的数组a，是结构体最后一位成员，并且大小未知，所以它就是所谓的柔性数组.

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

使用

#include<stdlib.h>
#include<stdio.h>
struct S
{
	int i;
	int a[];
};

int main()
{
	struct S* p = (struct S*)malloc(sizeof(struct S) + 100 * sizeof(int));//为柔性数组a提供100个整形空间
	if (p == NULL)
	{
		perror("malloc fail");
		return 1;
	}
	p->i = 100;
	for (int j = 0; j < 100; j++)
	{
		p->a[j] = j;
	}

	free(p);//释放
	p = NULL;
	return 0;
}

这样有什么好处呢？我个人觉得，首先这个柔性数组它的空间可以按照自己的需要来开辟，不会造成大量的空间浪费，还有就是方便释放，直接一次性free整个结构体指针即可。

---

end
生活原本沉闷，但跑起来就会有风！