【C】动态内存函数+经典笔试题@动态内存管理 —— malloc | free | calloc | realloc

已于 2022-06-24 19:40:28 修改
阅读量1.2k 收藏 13
点赞数 30
分类专栏： 小边的强势总结C语言篇 文章标签： c语言
于 2021-10-03 19:49:37 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_54851255/article/details/120517474
版权

本文重点

🔑引：为什么存在动态内存分配？

我们已经掌握的内存开辟方式有：

int a = 0;//4byte
int arr[10] = { 0 };//40byte

这样的开辟方式—

  1. 开辟空间大小是固定的，想大不能大，想小不能小；
  2. 定义数组时，必须给定大小，然而有时我们需要的空间大小在编译时才会知道。

在这里插入图片描述
由此引入动态内存开辟，这就要学习动态内存函数。

正文开始@一个人的乐队

1. 动态内存函数的介绍

1.1 malloc和free

1.1.1 malloc

C语言提供了一个动态内存开辟的函数:（头文件：#include<stdlib.h>）

void* malloc (size_t size);
  • void*:这块内存是为谁申请的也不知道，返回什么类型也不合适，那就返回通用类型。
  • size：要申请的字节数。

作为malloc函数的使用者，我很清楚我申请的内存空间要来做什么，在使用时要做强制类型转换:

int* ptr = (int*)malloc(10 * sizeof(int));

💛功能：在堆区上申请size个字节的空间，并返回堆区上的起始地址。

  • 若开辟成功，返回一个指向开辟好空间的指针；
  • 若开辟失败，则返回空指针NULL。

❄️因此，malloc的返回值一定一定要做检查！！！

1.1.2 搭配使用的free

C语言提供了另外一个函数用于做动态内存释放和回收的:
(头文件:#include<stdlib.h>)

void free(void* ptr);

💛功能：把ptr所指向的空间还给操作系统

注：

❄️1. 若参数ptr指向的空间不是动态开辟的，则free函数的行为是标准未定义的。
❄️2. 若参数ptr是NULL空指针，即free(NULL);okay,只不过什么都不干。

上代码感受它们的使用：
思考：free(ptr);后的ptr == NULL;是否有必要？

#include<stdio.h>
#include<stdlib.h>

int main()
{
	//申请空间
	int* p = (int*)malloc(10 * sizeof(int));
	if (p == NULL)
	{
		return -1;
	}
	//使用
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*(p + i) = i;
	}
	//释放ptr指向的这段内存
	free(p);
	//p = NULL;//是否有必要？
	return 0;
}

调试起来：
在这里插入图片描述
可以看到ptr指向的这段空间虽然释放了，但ptr依然指向这段空间（也就是说free根本就不会使ptr发生改变，也不会将ptr主动置空）。
在这里插入图片描述

此时ptr是野指针，很危险，就一定要ptr == NULL;，让ptr永远也找不到这段空间。

❄️3. 释放ptr指向的内存空间后free(ptr);，一定要将ptr置空ptr==NULL。

1.2 calloc

C语言还提供了一个calloc函数，也可用来动态内存分配:
(头文件:#include<stdlib.h>)

void* calloc (size_t num, size_t size);
  • void*:空类型，为了适应各种指针类型，以便正确解引用
  • num:要申请的元素个数
  • size:元素大小

💛功能：为大小为size的num个元素开辟一块空间，并将每一个字节都初始化为0.

  • 若开辟成功，则返回开辟好空间的起始地址
  • 若开辟失败，则返回空指针NULL

❄️因此，与malloc一样,对于calloc的返回值也一定一定要做检查！！！

上代码感受：

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<errno.h>

int main()
{
	//申请10个int的空间
	int* p = (int*)calloc(10, sizeof(int));
	if (p == NULL)
	{
		printf("%s", strerror(errno));//错误码翻译出错误信息
		return -1;
	}
	//申请成功
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d ", *(p + i));//打印
	}
	//释放
	free(p);
	p = NULL;
	return 0;
}

运行+调试结果：
在这里插入图片描述
演示申请空间失败的情况，申请空间过大：
在这里插入图片描述

对比malloc和calloc:

❄️malloc:只负责在堆区申请空间，并返回起始地址，不会初始化空间
❄️calloc:在堆区申请空间，初始化为0，并返回起始地址

以后也很简单，我要初始化我就用calloc,不想初始化我就用malloc.

1.3 realloc

有时我们发现过去申请的内存太小/过大了，为了合理使用内存就一定要对内存大小进行调整。
realloc函数的出现，让动态内存管理更加灵活.(头文件:#include<stdio.h>)

void* realloc (void* ptr, size_t size);
  • ptr:要调整的内存地址
  • size:调整后的新大小
  • void*:调整后的内存起始地址

❄️realloc在调整内存空间时存在两种情况：

💜情况1：原空间后有足够大的空间
在这里插入图片描述
💜情况2：原空间后没有足够大的空间
在这里插入图片描述

💛这个函数在调整原内存空间大小的同时，还会将原内存中的数据移动到新的空间中去。

上代码感受：

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<errno.h>

int main()
{
	int* p= (int*)malloc(10 * sizeof(int));
	if (p == NULL)
	{
		printf("%s\n", strerror(errno));
		return -1;
	}
	//申请成功
	//使用
	//...
	//空间不够，增加空间至20int
	int* ptr = (int*)realloc(p, 20 * sizeof(int));//用新指针来接收
	if (ptr == NULL)
	{
		return -1;
	}
	else
	{
		p = ptr;
	}
	
	int i = 0;
	for (i = 0; i < 20; i++)
	{
		*(p + i) = i;
	}
	//打印
	for (i = 0; i < 20; i++)
	{
		printf("%d ", *(p + i));
	}
	
	//释放
	free(p);
	p = NULL;
	return 0;
}

❤️注: 为什么这里一定要用新指针来接收：

//空间不够，增加空间至20int
int* ptr = (int*)realloc(p, 20 * sizeof(int));//用新指针来接收

//若仍用旧指针p来接收
int* p = (int*)realloc(p, 20 * sizeof(int));

不可，因为，若内存申请失败返回NULL，则原来p指向的空间也找不到了。

2. 常见动态内存错误

下面再次强化常见动态内存分配的错误点，以后都要避免奥。

2.1 对动态开辟的空间越界访问

#include<stdio.h>
#include<stdlib.h>

void test()
{
	int* p = (int*)malloc(10 * sizeof(int));
	if (p == NULL)
	{
		return ;
	}
	//使用
	int i = 0;
	for (i = 0; i <= 10; i++)
	{
		*(p + i) = i;
	}
	//释放
	free(p);
	p = NULL;
}
int main()
{
	test();
	return 0;
}

运行结果：挂了😰
在这里插入图片描述

2.2 对NULL指针解引用

void test()
{
	 int *p = (int *)malloc(INT_MAX/4);
	 *p = 20;
	 free(p);
}

直接这样写代码是有风险的，若malloc申请内存空间失败，则返回NULL，*p = 20;则是对空指针解引用。
这就要求我们在申请空间后一定要进行判断，先判断，再使用。

✅更正— 在申请空间后一定要进行判断

void test()
{
	 int *p = (int *)malloc(INT_MAX/4);
	 if(p == NULL)
	 {
	 	return;
	 }
	 *p = 20;
	 free(p);
}

2.3 对非动态开辟的内存用free释放

void test()
{
	 int a = 10;//栈
	 int *p = &a;
	 free(p);//ok?
}

运行结果 — 又挂了😰
在这里插入图片描述

2.4 使用free释放动态开辟内存的一部分

上代码：

#include<stdio.h>
#include<stdlib.h>

int main()
{
	int* p = (int*)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的，必须是动态开辟内存的起始位置。

2.5 对同一块内存多次释放

#include<stdio.h>
#include<stdlib.h>

int main()
{
	int* p = (int*)malloc(10 * sizeof(int));
	free(p);
	free(p);//重复释放
	return 0;
}

运行结果—又挂了😰
在这里插入图片描述

✅更正：在free释放p指向的空间后，记得将p置空p = NULL;

#include<stdio.h>
#include<stdlib.h>

int main()
{
	int* p = (int*)malloc(10 * sizeof(int));
	free(p);
	p = NULL;
	free(p);//p为NULL，okay,只不过什么也不做
	p = NULL;
	return 0;
}

2.6 动态开辟的内存忘记释放(内存泄漏)

在堆区上申请的动态内存空间有两种回收方式：

  1. 主动free掉
  2. 当程序退出时，申请的空间也会回收

思考：

#include<stdio.h>
#include<stdlib.h>

int main()
{
	int* p = (int*)malloc(10 * sizeof(int));
	if (p == NULL)
	{
		return -1;
	}
	//使用
	//忘记释放了
	getchar();
	return 0;
}

运行起来，光标闪烁，getchar();等待接收字符，程序不结束，如果这段空间不被释放，造成了内存泄漏。

忘记释放不再使用的动态开辟的空间会造成内存泄漏—这块空间你又不用你又不释放，别人也无法使用，如果服务器7*24小时的在跑，那非常可怕，内存会被一点一点耗干。

✅动态开辟的内存空间，一定要释放，且要正确释放。

3. 经典笔试题

3.1 笔试题1

上代码思考：

#include<stdio.h>
#include<stdlib.h>
#include<string.h>

void GetMemory(char *p) 
{
	p = (char *)malloc(100);
}
void Test(void) 
{
	char *str = NULL;
	GetMemory(str);
	strcpy(str, "hello world");
	printf(str);//运行结果？
}
int main()
{
	Test();
	return 0;
}

运行结果—挂了😰
在这里插入图片描述

🔑解析:

在这里插入图片描述

🐟1°程序崩溃

①str传给p是值传递，p是str的一份临时拷贝，所以当malloc在堆上开辟的空间起始地址放在p中（即p指向了这段空间时），不会影响str，str仍为NULL。
②当str为空时，strcpy想把"hello world"拷贝到str所指向空间时，程序崩溃，因为NULL指向的空间是不能直接访问的（还记得strcpy模拟实现的时候进去就要断言吗）。

🐟2°内存泄漏

更可怕的是想释放都没办法释放，函数调用完，p随之销毁(即malloc开辟出来的空间的起始地址丢失），这段空间无法找到，无从释放。

✅ 更正: 传址调用

void GetMemory(char** p) 
{
	*p = (char *)malloc(100);
}
void Test(void) 
{
	char *str = NULL;
	GetMemory(&str);
	strcpy(str, "hello world");
	printf(str);//运行结果？

	//释放
	free(str);
	str = NULL;
}

运行结果:
在这里插入图片描述
❤️注:
这里大家可能有疑惑在printf(str);。

char* p = "hello world";
printf("hello world");
printf(p);//okay！

3.2 笔试题2

上代码思考:

#include<stdio.h>
#include<stdlib.h>

char* GetMemory(void) 
{
	char p[] = "hello world";
	return p;
}
void Test(void) 
{
	char *str = NULL;
	str = GetMemory();
	printf(str);//运行结果？
}
int main()
{
	Test();
	return 0;
}

运行结果 — 打印随机值😰
在这里插入图片描述

🔑解析 — 事实上，这都属于返回栈空间地址引发的问题

在这里插入图片描述
像这样返回栈空间地址就是典型的造成野指针的原因之一。

与之相似的错误代码演示:

#include<stdio.h>

int* test()
{
	int n = 10;
	return &n;
}

int main()
{
	int* p = test();
	printf("%d\n", *p);
	return 0;
}

预测运行结果：可能打印随机值。

运行结果—虽然报了一个警报，但还是打印了10
在这里插入图片描述
这可能会让你震惊，这里打印10也并非巧合，如果还没调用其他函数，销毁的空间未被覆盖掉，确实可能访问到10.

我当然也可以让它不是10，这里随便打印一个"hehe":

int main()
{
	int* p = test();
	printf("hehe\n");
	printf("%d\n", *p);//运行结果？
	return 0;
}

再来运行，运行结果— 随机值
在这里插入图片描述
解析—画图简述函数栈桢创建与销毁：
在这里插入图片描述
这些讨论，都是为了说明返回栈空间地址时的这种错误。

3.3 笔试题3

#include<stdio.h>
#include<stdlib.h>
#include<string.h>

void GetMemory(char **p, int num) 
{
	*p = (char *)malloc(num);
}
void Test(void) 
{
	char *str = NULL;
	GetMemory(&str, 100);
	strcpy(str, "hello");
	printf(str);
}
int main()
{
	Test();
	return 0;
}

在这里插入图片描述

问题：内存泄漏！！

✅要记得释放空间：

free(str);
str = NULL;

3.4 笔试题4

#include<stdio.h>
#include<stdlib.h>
#include<string.h>

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;
}

有结果也不对，要明白编译器是不能查出所有错误的，不然要你程序猿干嘛。
在这里插入图片描述

🔑解析

在这里插入图片描述
因此，还是要记得free后，将str置空。

free(str);
str = NULL;

4. C/C++程序的内存开辟

在这里插入图片描述
C/C++程序内存分配的几个区域：

  1. 栈区（stack）：在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行 结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限，因此会有栈溢出的情况。
    栈区主要存放运行函数而分配的局部变量、函数参数、返回数据、 返回地址等。
  2. 堆区（heap）：一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS(操作系统)回收 。分配方式类似于链表。
  3. 数据段/静态区(static):存放全局变量、静态数据。程序结束后由系统释放。
  4. 代码段：存放函数体（类成员函数和全局函数）的二进制代码。

有了这幅图，我们就可以更好的理解static关键字修饰局部变量的例子了。

实际上普通的局部变量是在栈区分配空间的，栈区的特点是在上面创建的变量出了作用域就销毁。
但是被static修饰的变量存放在数据段（静态区），数据段的特点是在上面创建的变量，直到程序结束才销毁，所以生命周期变长。

下篇文章将介绍柔型数组。
未完待续

浮光 掠影
关注
  • 30
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 12
    评论
专栏目录
malloc 动态内存分配几个经典面试题
weixin_44077227的博客
04-19 672
#define _CRT_SECURE_NO_WARNINGS #include <stdio.h> #include <stdlib.h> #include<string.h> // //void test() { // int i; // int* ptr = (int*) malloc (10*sizeof(int)); // if(NULL == pt...
【C语言/基础梳理/期末复习】动态内存管理思维导图
最新发布
02-03
#### 四、动态内存经典笔试题分析 - **test1**: `GetMemory`函数试图通过值传递的方式返回`malloc`开辟的空间地址，但这种方式无效，因为函数结束后形参所占用的空间会被自动释放，导致实参仍然为NULL。此外，还存在...
百度笔试题：malloc/free与new/delete的区别
yuanlanjun
09-19 384
相同点：都可用于申请动态内存和释放内存 不同点： （1）操作对象有所不同。 malloc与free是C++/C 语言的标准库函数，new/delete 是C++的运算符。对于非内部数据类的对象而言，光用maloc/free 无法满足动态对象的要求。对象在创建的同时要自动执行构造函数， 对象消亡之前要自动执行析构函数。由于malloc/free 是库函数而不是运算符，不在编译器控制权限之内，不...
【C语言】关于malloc经典的笔试题
fufufu_的博客
09-28 687
【C语言】关于malloc经典的笔试题
c语言考试题及答案malloc,C语言笔试题【qianlong】 Part A  1. ptr = (char *)malloc(0)...
weixin_28720767的博客
05-18 360
Part A:1.What does the code fragment output and why?char *ptr;if((ptr=(char *)malloc(0))==NULL)puts("Got a null pointer");elseputs("Got a valid pointer");解题第一步：读懂代码，首先要知道malloc()的作用：而malloc(0)有意味着什么呢？...
malloc笔试题解析
yexixi06的博客
04-01 175
void GetMemory(char *p) { p = (char *)malloc(100); } void Test(void) { char *str = NULL; GetMemory(str); strcpy(str, "hello world"); printf(str); } test函数调用时，内部创建了指针变量str，它是一个局部变量。当把 实参str传给形参p时，形参p是一份临时拷贝，它有自己的独立空间。 malloc申请的空间，放进p时，并不会影响到str。 当.
2018年9月新华三C语言笔试题
05-01
5. 内存管理：动态内存分配（malloc，calloc，realloc，free）以及栈和堆的区别。 6. 文件操作：涉及打开、读写、关闭文件，以及文件指针的操作。 7. 位运算：位移、按位与、按位或、按位异或等操作及其应用。 8....
全国专升本c语言笔试题库+答案
01-14
7. **内存管理**：掌握动态内存分配（malloc、calloc、realloc、free）的概念和用法，避免内存泄漏和悬挂指针。 8. **错误处理**：学习使用errno和perror来处理运行时错误，提高程序的健壮性。 9. **位运算**：...
超全的C语言嵌入式工程师笔试面试题汇总，C语言版嵌入式工程师笔试面试题
01-13
- 静态、动态内存分配：了解malloc()、calloc()、realloc()、free()等函数的使用，以及内存泄漏问题。 - 内存对齐：理解数据在内存中的排列方式，以及alignof和offsetof等关键字的应用。 4. **预处理宏** - 宏...
经典C语言面试笔试题
10-02
4. **动态内存管理**：掌握malloc、calloc、realloc、free等函数的用法，理解内存泄漏和内存碎片问题。 5. **预处理器**：理解宏定义、条件编译指令(#ifdef, #ifndef, #endif)等预处理功能。 6. **文件操作**：...
关于malloc问题的改错-笔试常考
weixin_33888907的博客
10-26 224
情形1 #include<stdio.h> #include<stdlib.h> #include<string.h> voidGetMemory(char*p) { p=(char*)malloc(100); } voidTest(void) { char*str=NULL; ...
【C语言-54】动态内存管理，malloc,free,calloc,relloc,详解，经典题；
白小鱼的博客
05-18 285
目录 动态内存管理： 常用内存开辟方式和优缺点： 动态内存函数介绍： malloc和free：c语言提供的动态开辟函数 calloc: realloc: 常见动态内存错误: 经典笔试题: 动态内存管理： 常用内存开辟方式和优缺点： 常见内存开辟： int val =20；//栈空间上开辟四个字节; char arr[20]={0}; //在栈空间上开辟20个...
c语言中的动态内存管理-举例说明-malloc free calloc realloc
belongHWL的博客
07-18 194
阿鲤将以以下顺序介绍c语言的动态内存管理 一：为什么存在动态内存分配； 二：动态内存函数的介绍； 1：malloc 2：free 3：calloc 4：realloc 三：常见的动态内存错误； 四：几个经典的笔试题； 五：柔性数组； 一：为什么存在动态内存分配； 在阿鲤以前的学习中，开辟内存都是以以下方式进行的，int a; char arr[10]但是这样开辟出来的空间是固定的；而有时候需要的空...
一个关于malloc的面试题
Hani的专栏
04-30 1871
发表于1年前(2014-04-04 13:31)   阅读（176） | 评论（0） 9人收藏此文章, 我要收藏 赞0 慕课网，程序员升职加薪神器，点击免费学习 前两天看了一个关于malloc的面试题，题目是这样的： ? 1 2 3 4 5 6 7 8 9 10 11 void GetMemory(c
动态分配【malloc,free函数】详细介绍和典型实例分析
m0_63568001的博客
07-02 1647
malloc,free函数详细介绍和典型分析实例 malloc()用于申请一块连续的指定大小的内存块区域、以void*类型返回分配的内存区域地址，当无法知道内存具体位置的时候，想要绑定真正的内存空间，就需要用到动态的分配内存。malloc（free）函数头文件#include 注意这点：如果所申请的内存块大于目前堆上剩余内存块（整块），则内存分配会失败，函数返回NULL。注意这里说的“堆上......
考研王道初级阶段C语言基础入门
m0_46391680的博客
03-23 244
week4-day11作业 Description 输入一个整型数，然后申请对应大小空间内存，然后读取一个字符串，字符串的输入长度小于最初输入的整型数大小，最后输出输入的字符串即可（无需考虑输入的字符串过长，超过了内存大小）； 注意下面问题： char *p; scanf("%d",&n); p=malloc(n); scanf("%c",&c);//注意在scanf和gets中间使用scanf("%c",&c),去除换行 gets(p); Input 一
编程练习12(动态内存管理malloc等)
mzc的博客
04-25 154
malloc的实现 //malloc #include <stdio.h> #include<stdlib.h> int main(){ //malloc()中表示的是申请内存空间的大小 int *p = (int*)malloc(10 * sizeof(int)); for (int i = 0; i < 10;++i ) { p[i] = i; }...
malloc和strcpy，入门的指针面试题
不断debug，优化中……
04-09 550
不管是面试还是工作，在做linux应用时，是经常遇到的。结合例子简单介绍锁和条件变量。
C语言动态内存管理详解：malloc、free、calloc和realloc
C语言提供了四个动态内存函数：`malloc`、`free`、`calloc`和`realloc`。下面我们将详细介绍每个函数的用法和原理。 **malloc和free函数** `malloc`函数用于申请一块连续的内存空间，并返回指向这块空间的指针。其...
评论 12
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

浮光 掠影

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值