本文主要是介绍动态内存管理(malloc,calloc,realloc,free)+经典笔试题,希望对大家解决编程问题提供一定的参考价值,需要的开发者们随着小编来一起学习吧!
动态内存管理
- 一. malloc 和 free
- 1. malloc
- 2. free
- 二. calloc
- 三. realloc
- 四.动态内存的错误
- 1.对NULL指针的解引用操作
- 2.对动态开辟空间的越界访问
- 3.对非动态开辟内存使用free释放
- 4.使用free释放一块动态开辟内存的一部分
- 5.对同一块动态内存多次释放
- 6.动态开辟内存忘记释放(内存泄漏)
- 五.动态内存经典笔试题分析
前言:
- 当我们要开辟一块连续的内存空间时,我们第一时间想到的可能是数组。但是一但开辟了数组,数组的大小就确定了,无法调整数组的大小。
- 有时候我们需要的空间大小在程序运行的时候才能知道,那数组的编译时开辟空间的方式就不能满足了。
- 于是动态内存开辟函数(malloc,calloc,realloc,free)应运而生,下文带您一一了解其中的奥秘。
一. malloc 和 free
1. malloc
void* malloc(size_t size);
解释:在堆区中开辟一块大小为 size 个字节的空间,返回指向这块空间的起始地址(泛型指针void*)。
因为这块空间存放的数据类型不知(由程序员自己确定),所以用泛型指针接收该地址,在使用的时候记得养成一个好习惯:强制类型转换为自己需要的数据类型。
-
如果开辟成功,则返回一个指向开辟好空间的指针。
-
如果开辟失败,则返回一个 NULL 指针,因此malloc的返回值一定要做检查。
-
返回值的类型是 void* ,所以malloc函数并不知道开辟空间的类型,具体在使用的时候程序员自己来决定。
-
如果参数 size 为0,malloc的行为是标准是未定义的,取决于编译器。
2. free
void free(void* ptr);
解释:free是用来对动态内存的释放和回收的。free 对指针 ptr 指向的内容释放掉,但是指针仍然指向这块空间,若后面不再使用,及时将 ptr 置为 NULL,否则产生野指针。
-
如果参数 ptr 指向的空间不是动态开辟的,那free函数的行为是未定义的。
-
如果参数 ptr 是NULL指针,则函数什么事都不做。
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
int main()
{//在堆区申请10个整形空间int* p=(int*)malloc(10*sizeof(int));if (p == NULL){//开辟空间失败perror("malloc");//打印错误信息//printf("%s\n", strerror(errno));//也是打印错误信息return 1;}//使用这块空间int i = 0;for (i = 0; i < 10; i++){*(p + i) = i + 1;}//打印这块空间for (i = 0; i < 10; i++){printf("%d ", *(p + i));}//释放这块空间free(p);//将这块空间还给了操作系统,我们已经没有权限再使用这块空间了//但是p仍然指向那块空间p = NULL;//若不将p置为NULL,那么p就是野指针return 0;
}
总结:
- 动态内存开辟的函数头文件都是 stdlib.h。
- 如果不释放的话,程序结束的时候也会被操作系统自动释放。
- 但是为了防止内存泄漏,将其置为NULL。这是一个好习惯。
二. calloc
void* calloc(size_t num, size_t size);
解释:在堆区中开辟一块大小为 num * size 个字节的空间,返回指向这块空间的起始地址,其中 num 为数据的个数,size 为单个数据的字节数,同时把申请的空间的每个字节初始化为全为0。
#include<stdio.h>
#include<stdlib.h>
int main()
{//在堆区申请10个整形空间int* p = (int*)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
void* realloc (void* ptr, size_t size);
解释:调整动态内存开辟的空间,ptr 是那块空间的起始地址,size 是调整后的那块空间的字节的个数,返回指向这块空间的起始地址。
#include<stdio.h>
#include<stdlib.h>
int main()
{//在堆区申请10个整形空间int* p = (int*)malloc(10 * sizeof(int));if (p == NULL){perror("malloc");return 1;}//调整空间——变成20个整形空间int* ptr = (int*)realloc(p, 20 * sizeof(int));//注意:要用新的指针来接收if (ptr != NULL){p = ptr;}else{//开辟失败return 1;}int i = 0;for (i = 0; i < 20; i++){*(p + i) = i + 1;}for (i = 0; i < 20; i++){printf("%d ", *(p + i));}//释放free(p);p = NULL;return 0;
}
注意:也许有些人有疑问为什么要用新的指针接收返回的地址,直接用原来的指针接收不行吗?答案是不行的,在realloc调整动态内存开辟的空间有3中情况,代码如下:
int main()
{int* p = (int*)malloc(10);//...if (p != NULL){int* ptr = (int*)realloc(p, 20);//...}return 0;
}
情况1:
- 开辟的空间后面有足够且连续的空间,只需返回空间的起始地址即可。
情况2:
- 如果后续的空间不够,realloc 函数直接在堆区找一块新的满足大小的空间,将旧的地址,拷贝到新的地址。
- 自动释放旧的地址指向的空间,不需要手动 free,返回新的空间的起始地址。
情况3:
- 堆区已经没有满足情况的连续空间了,返回NULL。
realloc函数也能开辟空间,代码如下:
#include<stdio.h>
#include<stdlib.h>
int main()
{int* p = (int*)realloc(NULL, 10 * sizeof(int));//等价于malloc(40)if (p == NULL){//...}return 0;
}
四.动态内存的错误
1.对NULL指针的解引用操作
- 如果将一个空指针(NULL)进行解引用操作,程序会遇到未定义行为,会导致程序崩溃。这是因为空指针并不指向任何有效的内存地址,尝试解引用它会导致访问非法内存,从而导致程序崩溃。
- 因此,在解引用指针之前,应该始终先检查指针是否为空。
错误代码如下:
#include<stdio.h>
#include<stdlib.h>
int main()
{int* p = (int*)malloc(10 * sizeof(int));//可能会开辟失败导致,p等于NULL//if (p == NULL)//{// perror("malloc");// return 1;//}//使用int i = 0;for (i = 0; i < 10; i++){*(p + i) = i + 1;//如果p等于NULL,对其进行解引用操作,程序会崩溃}free(p);p = NULL;return 0;
}
2.对动态开辟空间的越界访问
#include<stdio.h>
#include<stdlib.h>
int main()
{int* p = (int*)malloc(10 * sizeof(int));if (p == NULL){perror("malloc");return 1;}//使用int i = 0;for (i = 0; i < 40; i++)//越界访问,程序崩溃{*(p + i) = i + 1;}free(p);p = NULL;return 0;
}
3.对非动态开辟内存使用free释放
#include<stdio.h>
int main()
{int a = 10;int* p = &a;//...free(p);//程序崩溃p = NULL;return 0;
}
4.使用free释放一块动态开辟内存的一部分
#include<stdio.h>
#include<stdlib.h>
int main()
{int* p = (int*)malloc(10 * sizeof(int));if (p == NULL){perror("malloc");return 1;}//使用int i = 0;for (i = 0; i < 5; i++){*p = i;p++;//修改了指针p}free(p);//free释放一块动态开辟内存的一部分,程序崩溃p = NULL;return 0;
}
5.对同一块动态内存多次释放
#include<stdio.h>
#include<stdlib.h>
int main()
{int* p = (int*)malloc(10 * sizeof(int));if (p == NULL){perror("malloc");return 1;}//使用free(p);//p为野指针//...free(p);//对同一块动态内存多次释放,程序崩溃p = NULL;return 0;
}
6.动态开辟内存忘记释放(内存泄漏)
- 内存泄漏:在程序执行过程中,动态分配的内存空间在程序不再需要时没有被正确释放的情况。这会导致程序在运行过程中持续耗费内存空间而不释放,最终可能导致系统性能下降,甚至导致程序崩溃。
#include<stdio.h>
#include<stdlib.h>
void test()
{int flag = 1;int* p = (int*)malloc(10 * sizeof(int));if (p == NULL)return;//使用if (flag)return;//未释放,函数提前结束,就找不到那块空间,导致内存泄漏free(p);p = NULL;
}
int main()
{test();//......//只有程序结束了,空间才被释放return 0;
}
- 在一些服务器上(腾讯,阿里…),可能7*7=49天一直在运行,若一直申请内存而不释放,内存迟早有一天会耗尽的,这会造成巨大损失。
- 动态内存管理是一把双刃剑:提供灵活的内存管理方式,但是会带来风险。
- 切记:动态开辟的空间一定要释放,并且正确释放。
五.动态内存经典笔试题分析
例题1:
解决办法:
- 传递 str 的地址通过地址修改 str ,同时可以释放动态内存开辟的空间。
- 返回动态内存开辟的空间的地址,可以释放动态内存开辟的空间。
例题2:
例题3:
解决办法:
创作不易,如果能帮到你的话能赏个三连吗?感谢啦!!!
这篇关于动态内存管理(malloc,calloc,realloc,free)+经典笔试题的文章就介绍到这儿,希望我们推荐的文章对编程师们有所帮助!