【动态内存管理】动态内存分配、常见错误、经典笔试题、柔性数组

最新推荐文章于 2022-11-13 10:01:04 发布
最新推荐文章于 2022-11-13 10:01:04 发布
阅读量3.2k 收藏 7
点赞数 9
分类专栏： C语言 文章标签： c语言 c++ 数据结构 动态内存
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_56884023/article/details/120460969
版权

目录

一、动态内存分配

1、为什么存在动态内存分配

  1. 空间开辟大小是固定的
  2. 数组在声明的时候，必须指定数组的长度，它所需要的内存在编译时分配
  1. 堆区
  2. malloc calloc realloc free

二、malloc

在堆区上申请size_t大小的空间 返回这块空间的起始位置

void* malloc(size_t t);

1、malloc、free

这个函数向内存申请一块连续可用的空间，并返回指向这块空间的指针。

  1. 如果开辟成功，则返回一个指向开辟好空间的指针。
  2. 如果开辟失败，则返回一个NULL指针，因此malloc的返回值一定要做检查。
  3. 返回值的类型是 void* ，所以malloc函数并不知道开辟空间的类型，具体在使用的时候使用者自己来决定。
  4. 如果参数 size 为0，malloc的行为是标准是未定义的，取决于编译器。

free函数用来释放动态开辟的内存。

  1. 如果参数 ptr 指向的空间不是动态开辟的，那free函数的行为是未定义的。
  2. 如果参数 ptr 是NULL指针，则函数什么事都不做。
#include <stdio.h>
#include <stdlib.h>

int main()
{
	// 1. 开辟空间
	int* p = (int*)malloc(40); // 申请40大小空间 把起始地址强转为int* 赋给p

	if (p == NULL)
	{
		return -1;
	}
	// 开辟成功了 可以使用
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*(p + i) = i;
	}

	// 2. 释放空间
	free(p);
	p = NULL; // 

	return 0;
}

2、calloc

void* calloc (size_t num, size_t size);

2.1、与malloc 的区别

malloc函数只负责在堆区申请空间，并且返回起始地址，不初始化空间
calloc函数在堆区上申请空间，并且在返回起始地址之前把申请的每个字节初始化为0

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

int main()
{
	int* p = (int*)calloc(10, sizeof(int));
	if (p == NULL)
	{
		printf("%s\n", strerror(errno));
		return -1;
	}
	// 申请成功
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d ", *(p + i));
	}

	// 释放空间
	free(p);
	p = NULL;

	return 0;
}

3、realloc

让动态内存管理更加灵活

void* realloc (void* ptr, size_t size);

ptr 是要调整的内存地址
size 调整之后新大小
返回值为调整之后的内存起始位置。
这个函数调整原内存空间大小的基础上，还会将原来内存中的数据移动到 新 的空间

两种情况：

  1. 后面空间大小够用，直接在后面开辟
  2. 空间不够，在堆空间上另找一个合适大小的连续空间来使用，这样函数返回的是一个新的内存地址
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main()
{
	int* p = (int*)calloc(10, sizeof(int));
	if (p == NULL)
	{
		printf("%s\n", strerror(errno));
		return -1;
	}
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*(p + i) = i;
	}

	// 空间不够大，增加空间至20int
	int* ptr = (int*)realloc(p, 20 * sizeof(int));
	if (ptr != NULL)
	{
		p = ptr;
	}
	else
	{
		return -1;
	}
	// 增加成功，使用
	for (i = 10; i < 20; i++)
	{
		*(p + i) = i;
	}
	for (i = 0; i < 20; i++)
	{
		printf("%d ", *(p + i));
	}

	free(p);
	p = NULL;

	return 0;
}

4、常见错误

4.1、 对malloc返回值判断
int* p = (int*)malloc(20);
*p = 0; // 有风险

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

int main()
{
	int* p = (int*)malloc(20);

	if (p == NULL)
	{
		return -1;
	}
	*p = 0;

	return 0;
}
4.2、对动态内存空间的越界访问
#include <stdio.h>
#include <stdlib.h>

int main()
{
	int* p = (int*)malloc(200);

	if (p == NULL)
	{
		return -1;
	}

	int i = 0;
	for (i = 0; i < 80; i++)
	{
		*(p + i) = 1;
	}
	
	for (i = 0; i < 80; i++)
	{
		printf("%d ", *(p + i));
	}

	free(p);
	p = NULL;

	return 0;
}
4.3、释放非动态内存空间
int main()
{
	int a = 10;
	int* p = &a;

	free(p); // err
	p = NULL;

	return 0;
}
4.4、使用free释放一块动态开辟内存的一部分

改变了p 不再指向起始位置 此时释放的不在 起始位置

#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++ = 1;
	}

	free(p);
	p = NULL;

	return 0;
}
4.5、对同一块动态内存多次释放
int main()
{
	int* p = (int*)malloc(40);
	if (p == NULL)
	{
		return -1;
	}

	free(p);
	free(p); // err
}

int main()
{
	int* p = (int*)malloc(40);
	if (p == NULL)
	{
		return -1;
	}

	free(p);
	p = NULL;

	free(p); // ok
}
4.6、动态开辟内存忘记释放（内存泄漏）

在堆区上申请空间，有2种回收方式，

  1. free
  2. 程序退出时，申请的空间回收
int main()
{
	int* p = (int*)malloc(40);
	if (p == NULL)
	{
		return -1;
	}
	// 没有释放

	return 0;
}

三、经典笔试题

题目一：

#include <stdio.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中时，不会影响str，str仍是NULL
  2. 当str是NULL，strcpy想把hello world拷贝到str指向的空间时，程序就会崩溃，因为NULL指针指向的空间时不能直接访问的
  3. 存在内存泄漏，出函数销毁，无法回收空间

修改：
版本1：

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

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

版本2：

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

char* GetMemory(char* p)
{
	p = (char*)malloc(100);
 
	return p;
}
 
void Test(void)
{
	char* str = NULL;
 
	str = GetMemory(str);

	strcpy(str, "hello world");
 
	printf(str);
	
	free(str);
	str = NULL;
}
 
int main()
{
	Test();
	return 0;
}

题目二：

#include <stdio.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);
	// 如果没有被覆盖,有可能输出10
	
	return 0;
}

题目三：

#include <stdio.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;
}

通过*p 用malloc给str在堆上开辟空间，
问题：

内存泄漏，没有free
free(str);
str = NULL;

改正：

#include <stdio.h>
#include <stdlib.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);

	free(str);
	str = NULL;
}

int main()
{
	Test();
	return 0;
}

题目四：

#include <stdio.h>
#include <stdlib.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;
}

在这里插入图片描述

改正：

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

void Test(void)
{
	char* str = (char*)malloc(100);

	strcpy(str, "hello");
	free(str);
	str = NULL;

	if (str != NULL)
	{
		strcpy(str, "world");
		printf(str);
	}
}

int main()
{
	Test();
	return 0;
}

四、C/C++程序的内存开辟

在这里插入图片描述

五、柔性数组

1、柔性数组成员

C99 中，结构中的最后一个元素允许是未知大小的数组，这就叫做『柔性数组』成员。

// 数组大小不确定，可大可小
typedef struct st_type
{
	int i;
	int a[0];//柔性数组成员
}type_a;
// 编译器报错无法编译可改成：
typedef struct st_type
{
	int i;
	int a[];//柔性数组成员
}type_a;

2、柔性数组的特点：

1. 结构中的柔性数组成员前面必须至少一个其他成员
	如 int a[] 前有 int i
2. sizeof 返回的这种结构大小不包括柔性数组的内存

#include <stdio.h>

typedef struct st_type
{
	int i;
	int a[];//柔性数组成员
}type_a;

int main()
{
	printf("%d\n", sizeof(struct st_type)); // 4
	return 0;
}

3. 包含柔性数组成员的结构体的使用，要配合malloc()这类动态内存分配函数使用

在这里插入图片描述

3、使用

实现之一：

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

struct st_type
{
	int i;
	int a[];
};

int main()
{
	struct st_type* ps = (struct st_type*)malloc(sizeof(struct st_type) + 10 * sizeof(int));
	// 4byte - i
	// 40byte - a

	if (ps == NULL)
	{
		printf("%s\n", strerror(errno));
		return -1;
	}
	// 开辟成功                                         
	ps->i = 100;
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		ps->a[i] = i;
	}

	for (i = 0; i < 10; i++)
	{
		printf("%d ", ps->a[i]);
	}

	// a数组的空间不够了，调为20个整型数据
	struct st_type* ptr = (struct st_type*)realloc(ps, sizeof(struct st_type) + 20 * sizeof(int));
	if (ptr == NULL)
	{
		printf("扩容空间失败");
		return -1;
	}
	else
	{
		ps = ptr;
	}

	// 使用...

	// 释放
	free(ps);
	ps = NULL;

	return 0;
}

实现之二：

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

struct st_type
{
	int i; // 4
	int* a; // 4
};

int main()
{
	struct st_type* ps = (struct st_type*)malloc(sizeof(struct st_type)); // 开辟8字节空间
	ps->i = 100;
	ps->a = (int*)malloc(10 * sizeof(int));

	int i = 0;
	for (i = 0; i < 10; i++)
	{
		ps->a[i] = i;
	}
	for (i = 0; i < 10; i++)

	{
		printf("%d ", ps->a[i]);
	}

	// 调整ps->a 空间
	int* ptr = (int*)realloc(ps->a, 20 * sizeof(int));
	if (ptr == NULL)
	{
		printf("扩容失败\n");
		return -1;
	}
	else
	{
		ps->a = ptr;
	}

	// 使用...

	// 释放
	free(ps->a);
	ps->a = NULL;
	free(ps);
	ps = NULL;

	return 0;
}
柔性数组的实现的好处：
  1. 方便内存释放
    只需一次free
  2. 有利于访问速度
    malloc 次数越多，内存碎片越多
    连续的内存有益于提高访问速度，也有益于减少内存碎片
    局部性原理： 内存-高速缓存-寄存器

C语言结构体里的数组和指针

三春去后诸芳尽
关注
  • 9
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 8
    评论
专栏目录
linux常见经典笔试题.docx
12-18
linux常见经典笔试题.docx
动态内存分配六种常见错误
Carrot_ly的博客
06-28 3969
1:对空指针解引用 用指针p接收malloc开辟的空间，然后没有判断是否分配成功就对这个空间进行赋值，此时如果分配失败，p为空指针，无法解引用并赋值 2:越界访问： 开辟的空间为n，由于不细心导致访问了n以外的内存，造成错误； 3:对非动态内存空间使用free 由于记忆错误对某不是指向动态内存空间的指针使用了free函数造成错误； 4:使用free释放了动态内存空间的一部分 由于不当操作使得原本指向动态内存空间的p的指向发生改变，不能读取到完整的空间，如果使用free就会造成错误 5:对同一动态内存空间多次
C语言动态内存管理（malloc，calloc，free，realloc）
Djsnxbjans的博客
09-24 774
带你深刻理解动态内存管理+面试题目 malloc free calloc realloc
使用动态内存可能出现的问题总结（笔试题解析）
Erica_ou的博客
08-02 5379
  在使用动态内存分配程序中，常常会产生不易发现的错误，这其中就包括对NULL指针进行解引用，访问未知内存区域（越界访问&amp;amp;amp;访问未初始化指针指向区域），内存泄漏，释放非动态内存开辟空间（向free函数传递一个并非由malloc函数返回的指针），释放动态内存开辟的部分空间，空间释放后利用指针被继续使用，不检查空间分配结果。 问题一：访问未知内存区域 问题二：对NULL指针进行解引用访问 ...
动态内存分配— —常见错误总结
m0_65635427的博客
11-13 409
C++动态内存分配— —常见错误总结
“史上最全”C语言动态内存及使用动态内存经常出现的错误
Sxy_wspsby的博客
09-26 654
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录 前言 一、pandas是什么？ 二、使用步骤 1.引入库 2.读入数据 总结 一、为什么会有动态内存？ 因为当前的内存分配有一定的局限性，例如使用数组只能开辟固定的空间而不能动态开辟，而动态内存能让我们想要多大空间就要多大空间。 二丶动态内存如何使用？ 了解并且会使用动态内存的函数，比如malloc函数，calloc函数，和realloc函数。 首先先讲解malloc函数，以下是ma
linux常见经典笔试题.doc
11-29
linux常见经典笔试题.doc
嵌入式常见经典笔试题
01-28
嵌入式常见经典笔试题
嵌入式常见经典笔试题.doc
08-02
嵌入式常见经典笔试题.doc
C语言笔试题常见错误
07-25
文中总结了C语言笔试题中比较常见的错误，希望大家有则改之，无则加勉。
C语言——动态内存分配之常见错误
linux2333的博客
10-21 318
C语言——动态内存分配之常见错误
动态分配内存常见错误
weixin_63954483的博客
03-21 611
动态开辟内存常见错误
C和指针 第11章 动态内存分配 11.5 常见的动态内存分配错误
weixin_客子光阴的博客
06-25 577
C和指针 第11章 动态内存分配 11.5 常见的动态内存分配错误
内存区划分；内存分配；堆、栈概念分析；动态内存管理数据结构及程序样例；核心态与用户态
青青的专栏--C/C++ OOA/D Design Pattern
07-05 3328
一. 在c中分为这几个存储区 1.栈 - 由编译器自动分配释放 2.堆 - 一般由程序员分配释放，若程序员不释放，程序结束时可能由OS回收 3.全局区（静态区），全局变量和静态变量的存储是放在一块的，初始化的全局变量和静态变量在一块区域，未初始化的全局变量和未初始化的静态变量在相邻的另一块区域。- 程序结束释放 4.另外还有一个专门放常量的地方。- 程序结束释放
C和指针之动态内存分配常见问题和总结
码莎拉蒂
12-02 2586
1、动态内存分配常见问题 1) 结构体成员指针未初始化 2）为指针分配内存太小 3）内存分配成功，但是没初始化 4)内存越界，内存泄漏，free多次或者释放之后没有设置为NULL 2、测试代码 #include #include #include //结构体成员指针需要初始化 struct studen
第六章内存的动态分配
huoyahuoya的博客
09-11 447
第六章内存的动态分配 为满足特殊需求 ，完善的操作系统，必须具备动态分配内存的能力，合理有效的分配内存是衡量操作系统品质的指标之一。且执行时间可确定。 6.1内存控制块：用来记录内存分区和内存分块的使用情况。 6.1.1可动态分配内存的划分 （1）为使用动态内存，需先划分出可动态分配的区域，这个区域叫内存分区，每个分区要包含若干个内存块。要求：分区中内存块的字节数必须相等，每个分区与该
也谈 释放动态分配的内存的时候出现的异常
jackyvan的专栏
08-23 1317
日前，在一段代码中调试中，发现对动态分配的内存进行释放时报错，DAMAGE: after Normal block （#293）at 0x002b23ed代码大体如下：…………………         {                   iarry=(MOBILE_INDEX**)malloc(days*sizeof(MOBILE_INDEX*));         
以下只有在使用时才为该类型变量分配内存的存储类说明是（）。
热门推荐
sinat_42550851的博客
08-20 1万+
auto 和 static auto 和 register register 和 static extern 和 register 解析： auto根据数据类型分配内存，register在使用到时分配CPU寄存器地址
华为笔试题 gpu计算力 数组元素代表每秒任务 java
最新发布
12-30
华为笔试题中的GPU计算力是指一台计算机GPU处理能力的指标，主要用于浮点计算和并行处理。对于数组元素代表每秒任务的Java语言，可以通过GPU计算力来加速任务处理的速度。 首先，我们需要将任务分配到不同的处理...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 8
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

三春去后诸芳尽

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

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

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

打赏作者

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

抵扣说明：

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

余额充值