提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档
文章目录
前言
提示：这里可以添加本文要记录的大概内容：
紧接上两章，我们已经学完C语言常用的3种自定义类型，这一章节，我们一起来学习C语言中的动态内存管理
提示：以下是本篇文章正文内容，下面案例可供参考
一、为什么要有动态内存分配
我们已经掌握的内存开辟⽅式有：
1.变量的创建，如：int a = 1;即在栈空间上开辟4个字节的内存空间
2.数组的创建，如：char arr[5] = {0};即在栈空间上开辟5个字节的连续空间
但是上述的开辟空间的⽅式有两个特点：
• 空间开辟⼤⼩是固定的
• 数组在申明的时候，必须指定数组的⻓度，数组空间⼀旦确定了⼤⼩不能调整
但是对于空间的需求，有时候我们需要的空间⼤⼩在程序运⾏的时候才能知道，那数组的编译时开辟空间的⽅式就不能满⾜了,于是C语⾔引⼊了动态内存开辟，让程序员⾃⼰可以申请和释放空间
二、动态内存分配函数
C语⾔提供了动态内存开辟函数malloc和calloc，调整动态开辟内存⼤⼩的函数realloc和专⻔⽤来做动态内存的释放和回收的函数free，接下来我们一起学习这几个动态内存分配函数
这几个动态内存分配函数都声明在头⽂件<stdlib.h>中
1.malloc
函数原型如下：
void* malloc (size_t size);//Size of the memory block, in bytes.即size是申请内存空间的大小，单位是字节
这个函数向内存申请⼀块连续可⽤的空间，并返回指向这块空间的指针
注意：
• 如果开辟成功，则返回⼀个指向开辟好空间的指针
• 如果开辟失败，则返回⼀个 NULL 指针，因此malloc的返回值⼀定要做检查
• 返回值的类型是 void* ，所以malloc函数并不知道开辟空间的类型，具体在使⽤的时候使⽤者⾃⼰来决定
• 如果参数 size 为0，malloc的⾏为是C语言标准未定义的，取决于编译器
2.calloc
函数原型如下：
void* calloc (size_t num, size_t size);//num是元素个数，size是每个元素的大小，单位是字节
//即为 num 个⼤⼩为 size 的元素开辟⼀块空间
与malloc一样的是：
• 如果开辟成功，则返回⼀个指向开辟好空间的指针
• 如果开辟失败，则返回⼀个 NULL 指针，因此calloc的返回值⼀定要做检查
• 返回值的类型是 void* ，所以calloc函数并不知道开辟空间的类型，具体在使⽤的时候使⽤者⾃⼰来决定
与malloc不一样的是：
• calloc与malloc的参数不一样
• calloc会在返回地址之前把申请的空间的每个字节初始化为全0
3.realloc
函数原型如下：
void* realloc (void* ptr, size_t size);//ptr是要调整的内存地址,size是调整之后的新⼤⼩
返回值为调整之后的内存起始位置
注意：
• 如果调整空间失败，则返回⼀个NULL指针，因此realloc的返回值也要做检查
• 如果调整空间成功，又分为两种情况
a.原有空间之后有⾜够⼤的空间
这种情况下，直接在原有空间后进行扩大，原来空间的数据不发⽣变化，扩大空间后，返回原来空间的起始地址
如图：
b.原有空间之后没有⾜够⼤的空间
这种情况下，无法直接在原有空间后进行扩大，realloc函数会在内存的堆区重新寻找一块空间（满足新的空间大小需求），在调整原内存空间⼤⼩的基础上，还会将原来内存中的数据移动到新的空间，然后释放原来的空间，同时返回新空间的起始地址
如图：
realloc函数除了能调整内存空间的大小外，也可以实现和malloc函数一样的功能
如下代码：
int*p = (int*)realloc(NULL, 40);//等价于malloc
即等价于
int*p = (int*)malloc(40);
4.free
malloc，calloc，realloc开辟的内存空间，如果不主动释放，出了作用域是不会销毁的，一直到整个程序结束，才会由系统回收，这样就可能会造成内存泄漏等一系列问题，所以C语言提供了一个专⻔⽤来做动态内存的释放的函数------free函数
函数原型如下：
void free (void* ptr);//ptr指向被释放内存空间
注意：
• 如果参数 ptr 指向的空间不是动态开辟的，那free函数的⾏为是未定义的
• 如果参数 ptr 是NULL指针，则函数什么事都不做
5.动态内存分配函数的使用练习
在了解完上述4个动态内存分配函数后，我们练习一下如何使用
例如：
#include<stdio.h>
#include <stdlib.h>
int main()
{
//int* p = (int*)malloc(10 * sizeof(int));
int* p = (int*)calloc(10 , sizeof(int));//使用malloc或calloc函数开辟空间，不同的是calloc会初始化
if (p == NULL) //对函数返回值进行检查
{
perror("calloc"); //如果出错，则打印错误信息
return 1;
}
//使用开辟好的内存空间
int i = 0;
for (i = 0; i < 10; i++)
{
*(p + i) = i;
}
//使用realloc扩大内存空间
int* ptr = (int*)realloc(p, 15 * sizeof(int));
if (ptr == NULL) //检查返回值
{
perror("realloc"); //如果出错，则打印错误信息
return 1;
}
else
p = ptr; //同步地址，方便操作
//使用扩大后的空间
for (i = 10; i < 15; i++)
{
*(p + i) = i;
}
//打印信息
for (i = 0; i < 15; i++)
{
printf("%d ", *(p + i));
}
//使用完后主动释放内存空间，避免内存泄漏
free(p);
p = NULL;//主动置为空指针，避免p成为野指针
return 0;
}
总结一下：
1.一定要对malloc，calloc，realloc函数的返回值进行检查
2.calloc开辟的内存空间会自动将每一个字节初始化为0，而malloc开辟的空间和realloc调整的空间不会初始化
3.使用完开辟的空间后要及时主动释放空间，避免内存泄漏，最后要及时将内存地址置为空指针，避免野指针
三、常⻅的动态内存的错误
1.对NULL指针的解引⽤操作
int main()
{
int* p = (int*)malloc(4);
*p = 20;//如果p的值是NULL，就会有问题
free(p);
p = NULL;
return 0;
}
如图：
解决方法：在解引用之前检查malloc函数的返回值，确保不为NULL
2.对动态开辟空间的越界访问
int main()
{
int i = 0;
int* p = (int*)malloc(10 * sizeof(int));
if (NULL == p)
{
return 1;
}
for (i = 0; i <= 10; i++)
{
*(p + i) = i;//当i是10的时候越界访问
}
free(p);
p = NULL;
return 0;
}
如图：
解决方法：使用动态开辟空间时不要越界访问
3.对⾮动态开辟内存使⽤free释放
int main()
{
int a = 10;
int* p = &a;
free(p);//ok?
p = NULL;
return 0;
}
如图：
解决方法：free释放的是由malloc，calloc和realloc开辟的内存空间，对⾮动态开辟内存不可使⽤free释放
4.使⽤free释放⼀块动态开辟内存的⼀部分
int main()
{
int* p = (int*)malloc(100);
p++;
free(p);//p不再指向动态内存的起始位置
return 0;
}
如图：
解决方法：free函数的参数就是动态内存的起始地址，所以不可以使⽤free释放⼀块动态开辟内存的⼀部分
5.对同⼀块动态内存多次释放
int main()
{
int* p = (int*)malloc(100);
free(p);
free(p);//重复释放
return 0;
}
如图：
解决方法：由于第一次已经释放了开辟的动态内存，即p已经不再指向动态内存空间，所以第二次使用free出错
6. 动态开辟内存忘记释放（内存泄漏）
void test()
{
int *p = (int *)malloc(100);
if(NULL != p)
{
*p = 20;
}
}
int main()
{
test();
while(1);
}
上述代码运行起来没有问题，但是在函数test()内开辟的动态内存空间在函数执行结束后没有释放掉，又由于 while(1);程序一直运行，即造成内存泄漏
解决方法：不再使用的动态内存空间应该及时释放，避免造成内存泄漏
四、柔性数组
1.什么是柔性数组
C99 中，结构中的最后⼀个元素允许是未知⼤⼩的数组，这就叫做『柔性数组』成员
即：在结构体中最后一个成员是未知大小的数组，这个数组就是柔性数组
例如：
typedef struct st_type
{
int i;
int a[0];//柔性数组成员
}type_a;
或者
typedef struct st_type
{
int i;
int a[];//柔性数组成员
}type_a;
2. 柔性数组的特点
- 结构中的柔性数组成员前⾯必须⾄少有⼀个其他成员
- sizeof 返回的这种结构⼤⼩不包括柔性数组的内存
- 包含柔性数组成员的结构⽤malloc ()函数进⾏内存的动态分配，并且分配的内存应该⼤于结构的⼤⼩，以适应柔性数组的预期⼤⼩
3.柔性数组的使⽤
下面通过一个例子来了解柔性数组是如何使用的：
#include<stdio.h>
#include<stdlib.h>
struct St
{
char c;
int n;
int arr[0];//柔性数组成员
};
int main()
{
struct St* ps = (struct St*)malloc(sizeof(struct St) + 10 * sizeof(int));//包含柔性数组成员的结构⽤malloc ()函数进⾏内存的动态分配
if (ps == NULL)
{
perror("malloc");
return 1;
}
//使用内存空间
ps->c = 'w';
ps->n = 100;
int i = 0;
for (i = 0; i < 10; i++)
{
ps->arr[i] = i;
}
//数组空间不够，用realloc扩大空间
struct St* ptr = realloc(ps, sizeof(struct St) + 15 * sizeof(int));
if (ptr != NULL)
{
ps = ptr;
}
else
{
perror("realloc");
return 1;
}
//...继续使用
for (i = 10; i < 15; i++)
{
ps->arr[i] = i;
}
//打印验证结果
for (i = 0; i < 15; i++)
{
printf("%d ", ps->arr[i]);
}
printf("\n%d\n", ps->n);
printf("%c\n", ps->c);
//释放
free(ps);
ps = NULL;
return 0;
}
使用柔性数组的好处：
- ⽅便内存释放：我们把结构体的内存以及其成员要的内存⼀次性分配好了，并返回给⽤⼾⼀个结构体指针，⽤⼾做⼀次free就可以把所有的内存也给释放掉
- 有利于访问速度：连续的内存有益于提⾼访问速度，也有益于减少内存碎⽚
总结
以上就是本篇文章的所有内容，本文向大家介绍了C语言的动态内存管理，希望对大家的学习有帮助！！！
扫一扫
4008
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
