🌈 个人主页：白子寰
🔥 分类专栏：魔法指针，进阶C++，C语言，C语言题集，C语言实现游戏👈 希望得到您的订阅和支持~
💡 坚持创作博文(平均质量分79.9+)，分享更多关于深度学习、C/C++领域的优质内容！（希望得到您的关注~）
目录
为什么会有动态内存的分配
malloc 和 free
动态内存开辟的函数：malloc函数
动态内存的释放和回收：free函数
calloc 和 realloc
动态内存分配：calloc函数
让动态内存管理更加灵活：realloc函数
relloc调整空间成功的两种情况
常见动态内存的错误
1）对NULL指针的解引用操作
错误示范
正确使用
2）对内存开辟空间的越界访问
错误示范
正确使用
3）对非动态开辟内存使用free释放
错误示范
正确使用
4）使用free释放一块动态开辟内存的一部分
错误示范
正确使用
5）对同一块动态内存的多次释放
错误示范
正确使用
6）动态开辟内存忘记释放（内存泄漏）
错误示范
正确使用
柔性数组
柔性数组的介绍
涉及到柔性数组的特点
代码①段
编辑
代码②段
两段代码的区别
为什么会有动态内存的分配
看下面代码：
①创建一个整型叫a并初始化赋值为10
②创建一个10个元素的数组，并全部初始化为0
int main()
{
int a = 10; //在栈区空间开辟了四个字节
int arr[10] = { 0 };//在栈区空间连续开辟了10*4=40个字节
return 0;
}于是我们发现上述开辟空间有两个特点：
①开辟空间大小是固定的；
②数组开辟空间是连续有长度的，且确定了空间大小不能改
malloc 和 free
malloc和free函数都需要包含头文件：include<stdlib.h>
动态内存开辟的函数：malloc函数
函数原型：void* malloc(size_t size);
作用：malloc函数向内存申请一块连续可用的空间，并返回指向这块空间的指针
注：返回值为void*，malloc函数开辟空间的类型由使用者自己决定
动态内存的释放和回收：free函数
函数原型：void* free(*ptr)
作用：free函数释放动态开辟的内存
注：
①如果ptr指向的空间不是开辟动态内存的，则free函数的行为是未定义的
②如果ptr是NULL指针则函数什么事都不做
#include<stdlib.h>
int main()
{
//int* p = (int*)malloc(10 * sizeof(int));
if (p == NULL)
{
perror("malloc");
return 1;//如果是空指针，返回1，下面代码不再执行
}
//使用
int i = 0;
for (i = 0; i < 10; i++)
{
//赋值
*(p + i) = i;
}
for (i = 0; i < 10; i++)
{
printf("%d ", *(p + i));
}
//释放空间
free(p);
p = NULL;//为了避免p成为野指针，最后要把p设置为空指针
return 0;
} 
calloc 和 realloc
动态内存分配：calloc函数
函数原型：void* calloc(size_t num,size_t size);
calloc和malloc函数的区别是：calloc函数可以把开辟的每一个值初始化为0
calloc和malloc函数的共同点是：能调整空间
让动态内存管理更加灵活：realloc函数
函数原型：void*（void* ptr,size_t size）;
其中ptr是要调整内存地址，size是调整之后的新大小
作用：对动态开辟内存大小做灵活的调整
int main()
{
int* p = (int*)calloc(10, sizeof(int));
if (p == NULL)
{
perror("malloc");
return 1;//如果是空指针，返回1，下面代码不再执行
}
//使用
int i = 0;
for (i = 0; i < 10; i++)
{
printf("%d ", *(p + i));//打印出来10个都是0，说明calloc函数是初始化值为0
}
int* ptr = (int*)realloc(p, 12);
if (ptr == NULL)
{
perror("realloc");//realloc调整空间失败返回NULL
return 1;
}
else
{
p = ptr;
}
//释放空间
free(p);
p = NULL;//为了避免p成为野指针，最后要把p设置为空指针
return 0;
}relloc调整空间成功的两种情况
常见动态内存的错误
1）对NULL指针的解引用操作
错误示范
正确使用
int main()
{
int* p = (int*)malloc(10 * sizeof(int));
//对p判断是否为空指针
if (p == NULL)
{
perror("malloc");
return 1;//如果是空指针，返回1，下面代码不再执行
}
//使用
*p = 20;
//释放空间
free(p);
p = NULL;//为了避免p成为野指针，最后要把p设置为空指针
return 0;
}
2）对内存开辟空间的越界访问
错误示范
正确使用
开辟内存空间多少，使用的时候就要对应多少
3）对非动态开辟内存使用free释放
错误示范
p取非动态内存，然后p在非动态内存使用free释放
正确使用
free函数原型：void* free(*ptr)
作用：free函数释放动态开辟的内存
如果ptr指向的空间不是开辟动态内存的，则free函数的行为是未定义的
4）使用free释放一块动态开辟内存的一部分
错误示范
p 不再指向动态内存的起始位置
正确使用
free函数释放时p要指向动态内存的起始位置
5）对同一块动态内存的多次释放
错误示范
正确使用
开辟动态内存使用完后一定要释放，并把p设置为空指针
6）动态开辟内存忘记释放（内存泄漏）
错误示范
正确使用
忘记释放不再使⽤的动态开辟的空间会造成内存泄漏
柔性数组
柔性数组的介绍
概念：在C99中，结构中的最后一个元素允许是未知大小的数组，这就叫【柔性数组】成员
我们先来看一段代码
struct st
{
int i;
int arr[0];//柔性数组成员
};
int main()
{
printf("%zd\n", sizeof(struct st));
return 0;
}这段代码输出什么？
答案：4
为什么？
涉及到柔性数组的特点
1）sizeof返回的结构大小不包括柔性数组的内存
2）结构中的柔性数组成员前面必须至少一个成员
以上两点都很好的解释上面👆的代码
3）包含柔性数组成员的结构用malloc函数进行内存的动态分配，并且分配的内存应该大于结构的大小，以适应柔性数组的预期大小
让我们接着讨论第三个特点
让我们想想，为什么要用柔性数组？
我们来看👇下面代码，代码有点长，每一段代码我注释了，供大家食用
代码①段
#include<stdlib.h>
//结构体
struct st
{
char ch;
int i;
int arr[0];
};
int main()
{
//printf("%zd\n", sizeof(struct st));//8
//结构体指针+malloc函数开辟空间
struct st* p = (struct st*)malloc(sizeof(struct st) + 10 * sizeof(int));
// 8 + 10 * 4 = 48
//判断p是否为空指针
if (p == NULL)
{
perror("malloc");
return 1;
}
//给结构体的成员赋值
p->i = 66;
p->ch = 'b';
int i = 0;
for (i = 0; i < 10; i++)
{
p->arr[i] = i;
}
//数组空间不够，realloc函数使用
struct st* ptr = realloc(p, sizeof(struct st) + 15 * sizeof(int));
if (ptr == NULL)
{
perror("realloc");
return 1;
}
else
{
p = ptr;
}
//继续使用
for (i = 10; i < 15; i++)
{
ptr->arr[i] = i;
}
//打印输出
for (i = 0; i < 15; i++)
{
printf("%d ", ptr->arr[i]);
}
printf("\n");
printf("%d\n%c\n", ptr->i, ptr->ch);
//释放空间
free(ptr);
ptr = NULL;
return 0;
}控制台结果显示
🆗，我们接着讨论为什么叫柔性数组？
代码②段
//结构体
struct st
{
char ch;
int i;
int *arr;
};
int main()
{
//printf("%zd\n", sizeof(struct st));//12
//结构体指针+malloc函数开辟空间
struct st* p = (struct st*)malloc(sizeof(struct st));
//判断p是否为空指针
if (p == NULL)
{
perror("malloc");
return 1;
}
//给结构体的成员赋值
p->i = 66;
p->ch = 'b';
p->arr = (int*)malloc(10 * sizeof(int));
if (p->arr == NULL)
{
perror("malloc.2");
return 1;
}
int i = 0;
for (i = 0; i < 10; i++)
{
p->arr[i] = i;
}
//数组空间不够，realloc函数使用
int* ptr = (int*)realloc(p->arr, 15 * sizeof(int));
if (ptr == NULL)
{
perror("realloc");
return 1;
}
else
{
p->arr = ptr;
}
//继续使用
for (i = 10; i < 15; i++)
{
p->arr[i] = i;
}
//打印输出
for (i = 0; i < 15; i++)
{
printf("%d ", p->arr[i]);
}
printf("\n");
printf("%d\n%c\n", p->i, p->ch);
//释放空间
free(p->arr);
p->arr = NULL;
free(p);
p = NULL;
return 0;
}
两段代码的区别
①段代码的两个优点
①方便内存释放
②利于访问速度
***********************************************************分割线*****************************************************************************
完结！！！
感谢浏览和阅读。
等等等等一下，分享最近喜欢的一句话:“不要取轻信别人定义的你们自己，只有你们可以自己定义你们自己”。
我是白子寰，如果你喜欢我的作品，不妨你留个点赞+关注让我知道你曾来过。
你的点赞和关注是我持续写作的动力！！！
好了划走吧。
