我们之前的内存开辟方式有局限性 :
空间开辟大小是固定的。
数组在申明的时候,必须指定数组的长度,它所需要的内存在编译时分配。
所以为了解决以上问题,我们需要学习动态内存开辟
- malloc函数可以向内存申请一块连续可用的空间,并返回指向这块空间的指针
- 如果开辟成功,则返回一个指向开辟好空间的指针。
- 如果开辟失败,则返回一个NULL指针,因此malloc的返回值一定要做检查。
- 返回值的类型是 void* ,所以malloc函数并不知道开辟空间的类型,具体在使用的时候使用者自己
来决定。- 如果参数 size 为0,malloc的行为是标准是未定义的,取决于编译器。
int main()
{
int* p = (int*) malloc(10 * sizeof(int));
if (p ==NULL)
{
perror("malloc");
return 0;
}
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; // 防止指针指向的空间释放,而导致出现野指针
}
专门是用来做动态内存的释放和回收的
- 如果参数 ptr 指向的空间不是动态开辟的,那free函数的行为是未定义的。
int main()
{
int a = 10;
int* p = &a;
free(p);//err
return 0;
}
- 如果参数 ptr 是NULL指针,则函数什么事都不做
- malloc 是申请空间,free是释放空间 ,也就是说malloc 和free 一般都是成对出现
- 函数的功能是为 num 个大小为 size 的元素开辟一块空间,并且把空间的每个字节初始化为0。
- 与函数 malloc 的区别只在于 calloc 会在返回地址之前把申请的空间的每个字节初始化为全0
int main()
{
int* p = calloc(10, sizeof(int));
if (p == NULL)
{
perror("calloc");
return 1;
}
int i = 0;
for (i = 0; i < 10; i++)
{
printf("%d ", *(p+i) );
}
free(p);
p = NULL;
return 0;
}
- realloc函数的出现让动态内存管理更加灵活。
- 有时会我们发现过去申请的空间太小了,有时候我们又会觉得申请的空间过大了,那为了合理的时
候内存,我们一定会对内存的大小做灵活的调整。那 realloc 函数就可以做到对动态开辟内存大小
的调整- realloc 有可能找不到合适的空间来调整大小 ,这时候就返回NULL
int main()
{
int* p = (int *)calloc(10, sizeof(int));
if (p == NULL) //开辟失败
{
perror("calloc");
return 1;
}
//开辟成功
int i = 0;
for (i = 0; i < 10; i++)
{
*(p + i) = 5;
}
//增容
int * ptr = (int *)realloc(p, 20*sizeof(int));
// 增容成功
if (ptr != NULL)
{
p = ptr;
}
free(p); //释放
p = NULL;
return 0;
}
第一种情况 ,realloc后面空间足够 ,返回原来的空间的数据(A)的地址
第二种情况 : realloc 后面的空间不足 , realloc 会再开辟一块空间(B) , 将原来的空间的数据(A)拷贝到新开辟的空间(B)处,并且会返回新开辟的空间(B)的首地址 ,同时会将原来的空间(A)还给操作系统 。
int main()
{
int*p = (int*)malloc(1000000000);
//对malloc函数的返回值,做判断
int i = 0;
for (i = 0; i < 10; i++)
{
*(p + i) = i;
}
return 0;
}
malloc 开辟空间可能会失败 ,失败返回NULL,对空指针解引用,会导致非法访问
所以我们一般对malloc函数返回值进行判断
int main()
{
int* p = (int*)malloc(10 * sizeof(int));
if (p == NULL)
{
return 1;
}
int i = 0;
//越界访问
for (i = 0; i < 40; i++)
{
*(p + i) = i;
}
free( p); //释放
p = NULL;
return 0;
}
malloc 函数只是开辟了10 个整形空间 ,上述代码会出现越界访问
int main()
{
int arr[10] = { 0 };//栈区
int* p = arr;
free(p);//使用free释放非动态开辟的空间
p = NULL;
return 0;
}
int main()
{
int* p = malloc(10 * sizeof(int));
//判断开辟成功
if (p == NULL)
{
return 1;
}
int i = 0;
for (i = 0; i < 5; i++)
{
*p++ = i;
}
//释放
free(p);
p = NULL;
return 0;
}
free 不完全释放空间
丢失了起始位置的地址,可能找不到这块空间 ,可能会导致内存泄漏
int main()
{
int* p = (int*)malloc(100);
//使用
//释放
free(p);
p = NULL;
//...
//释放
free(p); // 如果参数 ptr 是NULL指针,则free什么事都不做
return 0;
}
万一出现多次释放, 只要记得手动置成NULL ,如果参数 ptr 是NULL指针,则free函数什么事都不做,
void test()
{
int* p = (int*)malloc(100);
if (p == NULL)
{
return;
}
}
int main()
{
test();
//....
return 0;
}
动态开辟空间有两种回收方式 : 通过free函数主动释放 , 整个程序结束
p指向malloc 开辟空间的起始地址 。
p是局部变量,在栈区上开辟空间 , 出作用域就销毁
也就意味着丢失了malloc开辟空间的起始地址 ,就算后续再用free释放也无效
而且malloc开辟的空间并没有销毁,会一直吃内存,导致内存泄漏
void GetMemory(char *p) //p是形参,是str的一份临时拷贝
{
p = (char *)malloc(100);
}
void Test(void)
{
char *str = NULL;
GetMemory(str);
strcpy(str, "hello world");
printf(str);
}
int main()
{
Test():
return 0 ;
}
str传给GetMemory函数的时候是值传递,所以GetMemory函数的形参p是str的一份临时拷贝
在GetMemory函数内部动态申请空间的地址,存放在p中,不会影响str
所以GetMemory函数返回之后,str还是NULL 。
所以strcpy会拷贝失败
其次 ,当GetMemory函数返回之后,形参p销毁而且随着p的销毁,malloc创建的空间也找不到了,导致了内存泄漏,后续再使用free也无法释放 。
char *GetMemory(void)
{
char p[] = "hello world";
return p;
}
void Test(void)
{
char *str = NULL;
str = GetMemory();
printf(str);
}
GetMemory 函数内部创建的数组是在栈区上创建的,p数组进入GetMemory函数生命周期开始,出GetMemory 函数生命周期结束
return p 返回 数组首元素地址(h)
也就意味着str里面存的是h的地址
但是此时p数组里的空间还给操作系统
printf调用str,来打印p数组里的内容 , p数组里的内容很有可能被覆盖 ,(返回的地址是没有实际的意义,如果通过返回的地址,去访问内存就是非法访问内存的)
输出结果自然就是随机值
void GetMemory(char **p, int num)
{
*p = (char *)malloc(num);
}
void Test(void)
{
char *str = NULL;
GetMemory(&str, 100);
strcpy(str, "hello");
printf(str);
}
没有free函数释放malloc开辟的空间,可能会造成内存泄漏
void Test(void)
{
char *str = (char *) malloc(100);
strcpy(str, "hello");
free(str);
if(str != NULL)
{
strcpy(str, "world");
printf(str);
}
}
int main()
{
Test();
return 0 ;
}
malloc 开辟100个字节的内存空间,由str维护
strcpy函数将hello\0拷贝进malloc开辟的内存空间
strcpy函数将world\0拷贝进malloc开辟的空间 ,会失败
str 虽然记得malloc开辟空间的地址 ,但是此时malloc开辟的空间已经被free释放了,还给操作系统了,此时去访问内存就是非法访问内存的。
- 结构中的柔性数组成员前面必须至少一个其他成员。
- sizeof 返回的这种结构大小不包括柔性数组的内存。
struct S
{
int n;
int arr[0];
};
int main()
{
struct S s = { 0 };
printf("%d", sizeof(s)); // 输出4
return 0;
}
struct S
{
int n;
int arr[0];
};
int main()
{
struct S s = { 0 };
printf("%d", sizeof(s)); //输出4
return 0;
}
上述两种写法 ,看编译器支持哪一种
- 包含柔性数组成员的结构用malloc ()函数进行内存的动态分配,并且分配的内存应该大于结构的大
小,以适应柔性数组的预期大小。
struct S
{
int n;//4
int arr[0];//大小是未知
};
int main()
{
//期望arr的大小是10个整形
struct S* ps = (struct S*)malloc(sizeof(struct S) + 10 * sizeof(int));
return 0;
}
struct S
{
int n;//4
int arr[0];//大小是未知
};
int main()
{
//期望arr的大小是10个整形
struct S* ps = (struct S*)malloc(sizeof(struct S) + 10 * sizeof(int));
ps->n = 10;
int i = 0;
for (i = 0; i < 10; i++)
{
ps->arr[i] = i;
}
struct S* ptr = (struct S*)realloc(ps, sizeof(struct S) + 20 * sizeof(int));
if (ptr != NULL)
{
ps = ptr;
}
free(ps);
ps = NULL;
return 0;
}
- 方便内存释放
- 这样有利于访问速度.
如果你觉得这篇文章对你有帮助,不妨动动手指给点赞收藏加转发,给鄃鳕一个大大的关注
你们的每一次支持都将转化为我前进的动力!!!