1. 为什么存在动态内存分配
我们已经掌握的内存开辟方式有:
int val = 20;//在栈空间上开辟四个字节(创建一个变量:全局变量,局部变量)
char arr[10] = {0};//在栈空间上开辟10个字节的连续空间
1.创建一个变量(开辟一个变量的空间)
int a=10//局部变量-栈区
int g_a=10;//全局变量-静态区
2.创建一个数组(开辟一个数组的空间)
int arr[10]
局部数组放在栈区,全局数组放在静态区
struct s
{
char name [20];
int age;
}
int main()
{
struct s arr[50];//能够存放50个struct类型的数据
//浪费了30个空间
//60不够
return 0;
}
但是上述的开辟空间的方式有两个特点:
1. 空间开辟大小是固定的。
2. 数组在申明的时候,必须指定数组的长度,它所需要的内存在编译时分配。
但是对于空间的需求,不仅仅是上述的情况。有时候我们需要的空间大小在程序运行的时候才能知道,
那数组的编译时开辟空间的方式就不能满足了。
这时候就只能试试动态存开辟了。
动态内存分配是在堆上生成空间的。
2. 动态内存函数的介绍
2.1 malloc和free
C语言提供了一个动态内存开辟的函数:
void* malloc (size_t size);
size_t(unsigned int 无符号整型)
size所要开辟的空间的大小
返回类型为指针类型,即将所开辟好的空间的首地址传出
如果没有足够的内存可以使用的时候,会返回空指针NULL
这个函数向内存申请一块连续可用的空间,并返回指向这块空间的指针。
如果开辟成功,则返回一个指向开辟好空间的指针。
如果开辟失败,则返回一个NULL指针,因此malloc的返回值一定要做检查。
返回值的类型是 void* ,所以malloc函数并不知道开辟空间的类型,具体在使用的时候使用者自己 来决定。
如果参数 size 为0,malloc的行为是标准是未定义的,取决于编译器。
#include <stdio.h>//malloc函数的头文件
#include <string.h>//strerror函数的头文件
#include <errno.h>
#include <stdio.h>
int main()
{
//向内存申请10个整型的空间
int*p =(int*)malloc(10*sizeof(int));//返回类型为void*需要强制类型转换
if(p==NULL)
{
printf("%s\n",strerror(errno));//返回出错的原因,打印错误原因的一个方式
}
else
{
//正常使用空间
int i=0;
for(i=0;i<10;i++)
{
*(p+i)=i;//下标为i的那个元素
}
for(i=0;i<10;i++)
{
printf("%d",*(p+i));
}
}
//当动态申请的空间不再使用的时候
//就应该还给操作系统
free(p);//p依旧指向当前的地址位置
p=NULL//为了防止重新被找到p指针,将指针p命名为空指针,空指针将不会被使用
return 0;
}
C语言提供了另外一个函数free,专门是用来做动态内存的释放和回收的,函数原型如下:
void free (void* ptr);
需要引用头文件<stdlib.h>
free函数用来释放动态开辟的内存。
如果参数 ptr 指向的空间不是动态开辟的,那free函数的行为是未定义的。
如果参数 ptr 是NULL指针,则函数什么事都不做。 malloc和free都声明在 stdlib.h 头文件中。
malloc和free需要成对使用。
2.2 calloc
C语言还提供了一个函数叫 calloc , calloc 函数也用来动态内存分配。原型如下:
void* calloc (size_t num, size_t size);
函数的功能是为 num 个大小为 size 的元素开辟一块空间,并且把空间的每个字节初始化为0。
与函数 malloc 的区别只在于 calloc 会在返回地址之前把申请的空间的每个字节初始化为全0。
开辟一块空间,并且将元素初始化为0
元素的个数,每个元素的字节
返回一个指针,指向开辟好的空间
如果开辟失败,返回空指针
int main()
{
//malloc(10*sizeof(int));
int*p=(int*)calloc(10,sizeof(int));
if(p==NULL)
{
printf("%s\n",strerror(errno));
}
else
{
int i=0;
for(i=0;i<10;i++)
{
printf("%d",*(p+i));
}
}
//释放空间
//free函数是用来释放动态开辟的空间的。
free(p);
p=null;
return 0;
}
2.3 realloc
realloc函数的出现让动态内存管理更加灵活。
有时会我们发现过去申请的空间太小了,有时候我们又会觉得申请的空间过大了,那为了合理的时 候内存,我们一定会对内存的大小做灵活的调整。
那 realloc 函数就可以做到对动态开辟内存大小 的调整。
函数原型如下:
void* realloc (void* ptr, size_t size);
ptr 是要调整的内存地址
size 调整之后新大小
返回值为调整之后的内存起始位置。
这个函数调整原内存空间大小的基础上,还会将原来内存中的数据移动到 新 的空间。
realloc在调整内存空间的是存在两种情况:
情况1:原有空间之后有足够大的空间
情况2:原有空间之后没有足够大的空间
realloc可以调整动态开辟内存的大小
int main()
{
int*p=(int*)malloc(20);
if(p==NULL)
{
printf("%s\n",strerror(errno));
}
else
{
int i=0;
for(i=0;i<5;i++)
{
*(p+i)=i;
}
}
//就是在使用malloc开辟的20个字节的空间
//假设这里20个字节不能满足我们的使用了
//希望我们能够有40个字节的空间
//这里就可以使用realloc来调整动态开辟的内存
//
//realloc函数使用时的注意事项
1.如果p指向的空间之后有足够的内存空间可以追加,则直接追加,后返回p
2.如果p指向的空间之后没有足够的内存空间可以追加,则realloc函数会重新找一个新的内存区域
//开辟一块满足需求的空间,并把原来的内存中的数据拷贝过来,释放旧的内存空间,最后返回新开辟的内存空间的地址
3.realloc在开辟空间失败之后,会返回一个空指针,这就可能会导致当前原来指向一块较小的内存空间的指针被赋值为NULL从而导致原来内存空间的地址的丢失。所以需要将realloc所开辟的指针放到一个新的指针当中,进行判断,不是空指针再将指针的地址更换
int*ptr=realloc(p,int_max)
if(ptr !=NULL)
{
p=ptr;//这样就不会再realloc开辟失败之后将原来的指针给覆盖了。
}
情况1
当是情况1 的时候,要扩展内存就直接原有内存之后直接追加空间,原来空间的数据不发生变化。
情况2
当是情况2 的时候,原有空间之后没有足够多的空间时,扩展的方法是:在堆空间上另找一个合适大小 的连续空间来使用。这样函数返回的是一个新的内存地址。 由于上述的两种情况,realloc函数的使用就要注意一些。
int *p2=realloc(p,40);
int i=0
for (i=0;i<10;i++)
{
*(p2+i)=i;
}
for(i=0;i<10;i++)
{
printf("%d",*(p2+i));//前面输出的是之前的数值,后面补充的是随机值
}
//释放内存
free(p);
p=NULL;
return 0;
}
3. 常见的动态内存错误
3.1 对NULL指针的解引用操作
void test()
{
int *p = (int *)malloc(INT_MAX/4);
//万一malloc失败了,p就被赋值为空指针
*p = 20;//如果p的值是NULL,就会有问题
free(p);
}
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;//a是在栈区上开辟的空间,而free使用的对象是堆区的空间
free(p);//ok?
}
3.4 使用free释放一块动态开辟内存的一部分
void test()
{
int *p = (int *)malloc(100);
p++; free(p);//p不再指向动态内存的起始位置
}
//p在此代码中位置发生了变化,不再是一开始开辟的完整的动态内存空间了
#include<stdlib.h>
int*p=(int*)malloc(40);
int (p==NULL)
{
return 0;
}
int i=0;
for(i=0;i<10;i++)
{
*p++=i;
}
//回收空间
free(p);
return 0;
}
3.5 对同一块动态内存多次释放
void test()
{
int *p = (int *)malloc(100); free(p);
free(p);//重复释放
}
只要在free(p)之后将p的属性修改为空指针就不会发生错误
3.6 动态开辟内存忘记释放(内存泄漏)
void test()
{
int *p = (int *)malloc(100);
if(NULL != p)
{
*p = 20;
}
}
int main()
{
test();
while(1);
}
内存开辟之后一定要将内存还回去,否则会导致大量的内存的消耗