C语言——动态内存管理
1. 为什么需要动态内存管理
我们以往定义数组,都是这么定义的:
int nums[10] = {0};
以这种方式开辟空间有两个特点:
- 空间开辟的大小是固定的
- 数组在声明的时候,必须指定数组的长度,它所需要的内存在编译时分配
因此就导致了这样一个现象:我们无法在后续的过程中修改数组的大小,这是一个十分麻烦的事情
而为了解决这个问题,我们就需要学习动态内存开辟了
2. 动态内存函数的介绍
注:需要头文件
<stdlib.h>
需要知道,和静态开辟空间不一样,计算机是在堆上开辟的动态空间
2.1 malloc
void* malloc (size_t size);
这个函数向内存申请一块大小为size
字节的连续可用的空间,并返回指向这块空间的指针
- 如果开辟成功,则返回一个指向这块空间的指针
- 如果开辟失败,则返回一个空指针(NULL),因此我们一定要对
malloc
的返回值作有效性的判断 - 返回值为
void *
,因此当我们用指针变量接受这个返回值时,我们要将这个返回值强制转换为需要的类型 - 如果参数
size
为0,malloc
的行为是标准未定义的,
例如:
#include<stdio.h>
#include<stdlib.h>
int main()
{
//向内存申请40个字节的空间,并将返回的指针强制转换成int*型,并将其赋予指针nums
int *nums = (int*)malloc(sizeof(int) * 10);
//检验返回值的有效性
if (nums == NULL)
{
perror("malloc");
return 1;
}
//循环打印nums指向空间的值
for (int i = 0; i < 10; i++)
printf("%d\n", *(nums + i));
free(nums);
nums = NULL;
return 0;
}
output:
-842150451
-842150451
-842150451
-842150451
-842150451
-842150451
-842150451
-842150451
-842150451
-842150451
- 这说明,malloc申请到空间后,是不会对该空间初始化的
2.2 free
需要注意:凡是动态申请的内存,除非整个程序结束,申请的内存是不会主动归还给系统的,为了避免内存泄漏,我们应该使用函数free
来将申请的内存释放
void free (void* ptr);
free函数用来释放动态开辟的内存
- 如果参数``ptr
指向的空间不是动态开辟的,那
free`函数的行为是未定义的 - 如果参数
ptr
是NULL指针,则函数什么事都不做 - 正常释放后,ptr指向不明,称为野指针,因此,应该置为空(NULL)
例如:
#include<stdio.h>
#include<stdlib.h>
int main()
{
//向内存申请40个字节的空间,并将返回的指针强制转换成int*型,并将其赋予指针nums
int *nums = (int*)malloc(sizeof(int) * 10);
//检验返回值的有效性
if (nums == NULL)
{
perror("malloc");
return 1;
}
free(nums); //释放ptr所指向的动态内存
nums = NULL; //将野指针置空
return 0;
}
2.3calloc
void* calloc (size_t num, size_t size);
- 函数的功能是为
num
个大小为size
的元素开辟一块空间,并且把空间的每个字节初始化为0 - 与函数
malloc
的区别只在于calloc
会在返回指针之前把申请的空间的每个字节初始化为0
例如:
##include<stdio.h>
#include<stdlib.h>
int main()
{
//申请10个大小为4的空间,并让指针nums指向它
int* nums = (int*)calloc(10, sizeof(int));
//判断返回值的有效性
if(nums == NULL)
{
perror("calloc");
return 1;
}
//打印nums指向空间的元素
for (int i = 0; i < 10; i++)
printf("%d\n", *(nums + i));
free(nums);
nums = NULL;
return 0;
}
output:
0
0
0
0
0
0
0
0
0
0
2.4 realloc
所谓的动态内存管理,“内存管理”我们好像已经会了,那这个“动”又是怎么做到的呢?我们前面所学的malloc, calloc
好像并不能让申请的内存动起来呀。
要想实现对内存的增加或减小,就需要我们的函数realloc
:
void* realloc (void* ptr, size_t size);
-
ptr
是要调整的内存地址- 如果ptr不为空,那么就会修改ptr所指向空间的大小
- 如果ptr为空,那么就和
malloc
的功能相似,会直接返回一个指向大小为size
字节空间的指针
-
size
为调整之后的大小 -
返回值为调整之后的内存的起始位置
-
扩容后的空间不会被初始化
-
这个函数调整源内存空间大小的基础上,还会将原来内存中的数据移动到新的空间
-
ealloc
在调整内存空间时存在两种情况:- 情况一:原有空间之后有足够大的空间,那么就在原有的地方增容,并返回原来的起始地址
-
情况二:原有空间之后没有足够大的空间,那么就在合适的地方重新开辟一块大小为
size
的空间,将原来空间的数据拷贝到新空间,再释放掉原来的空间,最后再返回新空间的起始地址
-
如果调整失败,就会返回空指针,为了考虑到这种情况,我们应该避免以下的代码:
//error example
#include<stdio.h>
#include<stdlib.h>
int main()
{
int* nums = (int*)malloc(10 * sizeof(int));
if (nums == NULL)
{
perror("malloc");
return 1;
}
//如果开辟失败,那么nums就成了空指针,前面nums管理的40个字节的空间就找不到了,这样就造成了内存泄漏
nums = (int*)realloc(nums, 20 * sizeof(int));
if (nums == NULL)
{
perror("realloc");
return 1;
}
free(nums);
nums = NULL;
return 0;
}
- 正确的方式应该是这样的:
//right example
#include<stdio.h>
#include<stdlib.h>
int main()
{
int* nums = (int*)malloc(10 * sizeof(int));
if (nums == NULL)
{
perror("malloc");
return 1;
}
//先用一个中间变量temp接受
int* temp = (int*)realloc(nums, 20 * sizeof(int));
if (temp == NULL)
{
perror("realloc");
return 1;
}
//当temp有效时,再用nums接受
nums = temp;
free(nums);
nums = NULL;
return 0;
}
最后,再对realloc
的具体使用举个例子:
#include<stdio.h>
#include<stdlib.h>
int main()
{
//先动态开辟40个字节的内存
int* nums = (int*)malloc(10 * sizeof(int));
if (nums == NULL)
{
perror("malloc");
return 1;
}
//将这块空间初始化为0
memset(nums, 0, 10 * sizeof(int));
//将这块空间扩容到60个字节,并先用中间变量temp接受
int* temp = (int*)realloc(nums, 15 * sizeof(int));
if (temp == NULL)
{
perror("realloc");
return 1;
}
//确定temp有效后再用nums指向temp
nums = temp;
//打印扩容后空间的数据
for (int i = 0; i < 15; i++)
{
printf("%d\n", nums[i]);
}
//释放内存
free(nums);
nums = NULL;
return 0;
}
output:
0
0
0
0
0
0
0
0
0
0
-842150451
-842150451
-842150451
-842150451
-842150451
3. 常见的关于动态内存开辟的错误
3.1 对NULL指针的解引用操作
void test()
{
int *p = (int *)malloc(sizeof(int));
*p = 20; //如果p为空指针,就会有问题,一定先要检查返回指针的有效性
free(p)
}
3.2 对动态开辟空间的越界访问
void test()
{
int *p = (int *)malloc(10 * sizeof(int));
if(NULL == p)
{
perror("malloc");
return 1;
}
for(int i = 0; i <= 10; i++)
*(p + i) = i; //当i是10的时候就会越界访问
free(p);
}
3.3 对非动态开辟内存使用free释放
void test()
{
int nums[10] = {0};
free(nums);
}
3.3 对同一块动态内存多次free释放
void test()
{
int *p = (int *)malloc(10 * sizeof(int));
if(NULL == p)
{
perror("malloc");
return 1;
}
free(p);
free(p);
}
3.4 动态开辟内存忘记释放(内存泄漏)
void test()
{
int *p = (int *)malloc(10 * sizeof(int));
if(NULL == p)
{
perror("malloc");
return 1;
}
for(int i = 0; i < 10; i++)
*(p + i) = i;
}
4. 柔性数组(flexible array)
C99中,结构体中的最后一个元素允许是位置大小的数组,这就叫做柔性数组
例如:
typedef struct ST
{
int i;
int a[0]; //柔性数组成员,也可以写成 a[];
}ST;
4.1 柔性数组的特点
-
柔性数组前至少有一个其他成员
-
sizeof
返回的结构体大小不包含结构中柔性数组的内存,例如对于上面的代码:printf("%d\n",sizeof(ST));
output:
4
-
包含柔性数组成员的结构用malloc函数进行内存的动态分配,并且分配的内存应该大于结构的大小,以适应柔性数组的预期大小,同样,也可以用
realloc
进行增容,例如:文章来源:https://www.toymoban.com/news/detail-572323.html#include<stdio.h> #include<stdlib.h> typedef struct ST { int i; int a[]; //柔性数组成员 }ST; int main() { ST *st1 = (ST*)malloc(sizeof(ST) + sizeof(int) * 10); //向内存申请大小为结构大小加10个整型的内存空间 if (NULL == st1) { perror("malloc"); return 1; } st1->i = 10; //给空间赋值 for (int i = 0; i < 10; i++) (st1->a)[i] = i + 1; //打印空间元素 for (int i = 0; i < 10; i++) printf("%d\n", (st1->a)[i]); //增容,将内存扩大5个int型 ST* temp = (ST*)realloc(st1, sizeof(ST) + sizeof(int) * 15); if (NULL == temp) { perror("realloc"); return 1; } st1 = temp; //打印空间数据 for (int i = 0; i < 15; i++) printf("%d\n", (st1->a)[i]); //释放动态内存 free(st1); st1 = NULL; return 0; }
由上面的分析我们可以看到,我们完全可以在结构体里面创建一个整形指针(其他类型也可以),然后对其进行动态内存开辟就可以完全替代柔性数组的功能,因此柔性数组这一功能并不常用,我们仅作了解即可文章来源地址https://www.toymoban.com/news/detail-572323.html
到了这里,关于C语言——动态内存管理(malloc, calloc, realloc, free, 柔性数组详解)的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!