C动态内存管理

于 2024-10-02 19:20:19 发布
阅读量570 收藏 8
点赞数 17
文章标签： c语言 开发语言 笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2402_84532723/article/details/142679599
版权

前言：不知不觉又过去了很长的一段时间。今天对C语言中的动态内存管理进行一个系统性的总结。

1 为什么要有动态内存分配

在C语言中，使用int，float，double，short等数据内置类型以及数组不是也可以开辟内存空间吗？为什么还要有动态内存分配呢？这是因为以上方式开辟出来的内存空间有两个缺点。

. 空间开辟大小是固定的。

. 数组在声明的时候，必须指定数组的长度，数组空间一旦确定了大小无法调整。

但是对于空间的需求不仅仅是上述情况。有时候我们需要的空间大小在程序运行起来的时候才能知道。那么上述开辟空间的方式就不能满足了。因此C语言中引入了动态内存分配，，让程序员自己申请，释放空间，相对灵活。

2 malloc和free

2.1 malloc函数的介绍

//返回值类型是void*指针，参数类型是size_t,size是申请内存块的大小，单位是字节
//size_t是一个unsigned int类型
void* malloc(size_t size);

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

. 如果开辟成功，则返回一个指向开辟好空间的指针**。

. 如果失败，则返回一个NULL指针，因此malloc函数的返回值一定要做检查。

. malloc函数的返回类型是void*类型的指针，所以malloc函数并不知道开辟空间的类型，使用的时候由使用者自己来决定。

. 如果参数size为0,malloc的行为是标准未定义的，取决于编译器。

2.2 free函数的介绍

C语言提供了一个free函数，是专门用来释放，回收动态开辟出来的内存空间。

//返回值类型是void,参数类型是void*,ptr是指向先前由malloc或realloc或calloc分配的内存空间
void free(void* ptr);

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

. 如果参数ptr指向的空间不是动态开辟的，那么free函数的行为是未定义的。

. 如果参数ptr是NULL指针，那么free函数什么事都不做。

#include<stdio.h>
#include<stdlib.h>
int main()
{
	//动态申请内存空间
	int* ptr = (int*)malloc(10 * sizeof(int));
	//检查是否开辟成功
	if (NULL == ptr)
	{
		printf("malloc fail\n");
		exit(-1);
	}
	for (int i = 0; i < 10; i++)
	{
		*(ptr + i) = i + 1;
	}
	for (int i = 0; i < 10; i++)
	{
		printf("%d ", *(ptr + i));
	}
	//释放空间
	free(ptr);
	//改变ptr指针的指向
	ptr = NULL;
	return 0;
}

3 calloc和realloc

3.1 calloc函数的介绍

void* calloc(size_t num,size_t size);

calloc函数也是用来动态开辟内存的。

. calloc函数的功能是为num个大小为size的元素开辟一块空间，并把空间的每个字节初始化为0。

. 与malloc函数的区别在于calloc函数在返回地址之前会将申请的空间每个字节初始化为0。

#include<stdio.h>
#include<stdlib.h>
int main()
{
	//动态开辟10*sizeof(int)个字节
	int* p = (int*)calloc(10, sizeof(int));
	//检查是否开辟成功
	if (NULL == p)
	{
		printf("calloc fail\n");
		exit(-1);
	}
	//观察calloc函数开辟空间的内容
	for (int i = 0; i < 10; i++)
	{
		printf("%d ", *(p + i));
	}
	free(p);
	p=NULL;
	return 0;
}

3.2 realloc函数的介绍

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

realloc函数的功能是对空间的大小进行调整。

. ptr是要调整的内存地址。

. size是调整之后新的大小。

. 返回值是调整之后内存空间的起始地址。

. 这个函数调整原内存空间大小的基础上，还会将原来内存中的数据移动到新的内存空间。

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

1.原有内存空间之后有足够的空间。

2.原有内存空间之后没有足够大的空间。

在这里插入图片描述

情况1：在原有空间之后追加空间，原有空间的数据不发生变化。

情况2：原有空间之后没有足够的空间，扩展的方法是：在堆空间上找一个合适大小的连续空间来使用，并将原有空间的数据拷贝一份给新空间，释放原有空间，返回一个新的地址。

#include<stdio.h>
#include<stdlib.h>
int main()
{
	int* ptr = (int*)calloc(20);
	if (NULL == ptr)
	{
		printf("calloc fail\n");
		exit(-1);
	}
	//如果扩容失败会怎么样
	//原有数据也会丢失，不推荐这种写法
	ptr = realloc(ptr, 40);//ok?
	//这种写法更为安全
	int* tmp = (int*)realloc(ptr, 40);
	if (NULL == tmp)
	{
		printf("realloc fail\n");
		exit(-1);
	}
	ptr = tmp;
	free(ptr);
	ptr = NULL;
	return 0;
}

4 常见的动态内存错误

4.1 对NULL指针的解引用操作

void test()
{
	int* p = (int*)malloc(sizeof(int));
	if (NULL == p)
	{
		printf("malloc fail\n");
		exit(-1);
	}
	*p = 20;//如果p是NULL，就会有问题
	free(p);
	p = NULL;
}

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

void test()
{
	int* p = (int*)malloc(sizeof(int)*10);
	if (NULL == p)
	{
		printf("malloc fail\n");
		exit(-1);
	}
	for (int i = 0; i <= 10; i++)
	{
		*(p + i) = i;//i为10的时候就越界访问了
	}
	free(p);
	p = NULL;
}

4.3 释放一部分动态开辟空间

void test()
{
	int* p = (int*)malloc(sizeof(int) * 10);
	if (NULL == p)
	{
		printf("malloc fail\n");
		exit(-1);
	}
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*(p + i) = i;
	}
	for (i = 0; i < 5; i++)
	{
		printf("%d ", *p);
		p++;
	}
	//此时p不再指向动态开辟空间的起始地址，只释放了一部分空间，p就是野指针
	free(p);
	p = NULL;
}

4.4 对非动态开辟空间的释放。

void test()
{
	int a = 10;
	int* p = &a;
	//对非动态开辟内存的释放
	free(p);
	p = NULL;
}

4.5 对同一块动态内存多次释放

void test()
{
	int* p = (int*)malloc(sizeof(int) * 10);
	if (NULL == p)
	{
		printf("malloc fail\n");
		exit(-1);
	}
	free(p);
	free(p);//重复释放
	p = NULL;
}

4.6 动态开辟内存忘记释放（内存泄漏）

void test()
{
	int* p = (int*)malloc(sizeof(int) * 10);
	if (NULL == p)
	{
		printf("malloc fail\n");
		exit(-1);
	}
	//忘记释放
}

5 动态内存经典笔试题解析

5.1 题目一：

#include<stdio.h>
#include<stdlib.h>
void GetMemory(char* p)
{
	//动态开辟空间未进行释放，内存泄露
	p = (char*)malloc(100);
}
void Test(void)
{
	char* str = NULL;
	//str作为参数，这里传递的是NULL，形参的改变不会影响实参
	GetMemory(str);
	//因此str指向的内容还是NULL，无法对NULL指针进行访问，程序会崩溃
	strcpy(str, "hello world");
	printf(str);
}
int main()
{
	Test();
	return 0;
}

5.2 题目二：

#include<stdio.h>
#include<stdlib.h>
char* GetMemory(void)
{
	//局部变量
	char p[] = "hello world";
	//调用这个函数时为这个函数创建栈帧空间
	//调用之后这个函数的栈帧空间被销毁
	//局部变量也会被销毁，因此返回局部变量的地址会造成野指针
	return p;
}
void Test(void)
{
	char* str = NULL;
	//此时str就是一个野指针，对其进行访问就是非法访问
	str = GetMemory();
	printf(str);
}
int main()
{
	Test();
	return 0;
}

5.3 题目三：

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
void GetMemory(char** p, int num)
{
	//p是一个二级指针，接收的是一级指针变量str的地址
	//*p就是str
	*p = (char*)malloc(num);
}
void Test(void)
{
	char* str = NULL;
	//传递的是一级指针变量str的地址
	//形参的改变会影响实参
	GetMemory(&str, 100);
	strcpy(str, "hello");
	printf(str);
	//唯一的缺点就是没有进行动态内存释放，导致内存泄漏
}
int main()
{
	Test();
	return 0;
}

5.4 题目四：

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
void Test(void)
{
	char* str = (char*)malloc(100);
	strcpy(str, "hello");
	//free之后操作系统回收内存空间，但未将str置空,此时str就是野指针
	free(str);
	if (str != NULL)
	{
		//非法访问
		strcpy(str, "world");
		printf(str);
	}
}
int main()
{
	Test();
	return 0;
}

6 柔性数组

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

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

6.1 柔性数组的特点

. 结构体中柔性数组成员前面必须至少有一个其他成员。

. sizeof 计算结构体大小是不包括柔性数组大小的。

. 包含柔性数组成员的结构用malloc函数进行内存的动态分配，并且分配的内存应该大于结构的大小，以适应柔性数组的大小。

#include<stdio.h>
#include<stdlib.h>
typedef struct st_type
{
	//0~3
	int i;//4   8   4
	int arr[];//柔性数组成员
}type_a;
int main()
{
	printf("%zd\n", sizeof(struct st_type));//4
	return 0;
}

6.2 柔性数组的使用

#include<stdio.h>
#include<stdlib.h>
typedef struct st_type
{
	int i;
	int arr[];//柔性数组成员
}type_a;
int main()
{
	//100*sizeof(int)是为了适应柔性数组成员的大小
	type_a* p = (type_a*)malloc(sizeof(type_a) + 100 * sizeof(int));
	if (NULL == p)
	{
		printf("malloc fail\n");
		exit(-1);
	}
	p->i = 100;
	int i = 0;
	for (i = 0; i < 100; i++)
	{
		p->arr[i] = i;
	}
	for (i = 0; i < 100; i++)
	{
		printf("%d ", p->arr[i]);
	}
	free(p);
	p = NULL;
	return 0;
}

柔性数组的使用还可以这样完成。

#include<stdio.h>
#include<stdlib.h>
typedef struct st_type
{
	int i;
	int *a;//柔性数组成员
}type_a;
int main()
{
	type_a* p = (type_a*)malloc(sizeof(type_a));
	if (NULL == p)
	{
		printf("malloc fail\n");
		exit(-1);
	}
	p->i = 100;
	p->a = (int*)malloc(p->i * sizeof(int));
	if (p->a == NULL)
	{
		printf("p->a malloc fail\n");
		exit(-1);
	}
	int i = 0;
	for (i = 0; i < 100; i++)
	{
		p->a[i] = i;
	}
	for (i = 0; i < 100; i++)
	{
		printf("%d ", p->a[i]);
	}
	free(p->a);
	p->a = NULL;
	free(p);
	p = NULL;
	return 0;
}

比较两种方式，哪一种更好呢？第一种方法会更好一点。

1.方便内存释放

2.有利于访问速度（连续的空间有利于提高访问速度，也有利于减少内存碎片）。

7 C/C++中程序内存区域划分

在这里插入图片描述

1.栈区(stack):在执行函数时，函数内局部变量的存储单元都可以在栈上创建，
函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的
指令集中，效率很高，但是分配的内存容量有限。栈区主要存放运行函数而
分配的局部变量，函数参数，返回数据，返回地址等。

2.堆区(heap):一般由程序员分配释放，若程序员不释放，程序结束时可能由
OS回收。分配方式类似于链表。

3.数据段(静态区)(static):存放全局变量，静态数据。程序结束后由系统释放。

4.代码段：存放函数体(类成员函数和全局函数)的二进制代码。
特种加菲猫
关注
深入详解C/C++动态内存管理
dvlinker的技术专栏
07-19 1万+
本文详细讲述了C/C++动态内存管理方面的内容，并具体阐述了几类常见的动态内存异常，以供大家借鉴或参考！
C语言动态内存管理经典笔试题
weixin_73496371的博客
03-11 1067
C/C++程序内存分配的⼏个区域：1. 栈区（stack）：在执⾏函数时，函数内局部变量的存储单元都可以在栈上创建，函数执⾏结束时这些存储单元⾃动被释放。栈内存分配运算内置于处理器的指令集中，效率很⾼，但是分配的内存容量有限。栈区主要存放运⾏函数⽽分配的局部变量、函数参数、返回数据、返回地址等。2. 堆区（heap）：⼀般由程序员分配释放，?若程序员不释放，程序结束时可能由OS回收。分配⽅式类似于链表。3. 数据段（静态区）（static）存放全局变量、静态数据。程序结束后由系统释放。
C语言动态内存管理
C语言实战技术
03-04 372
文章目录一、相关的库函数1、malloc 函数2、free 函数二、内存被耗尽三、野指针1、指针变量未初始化2、指针释放后之后未置空四、应用经验1、数组申明的改进2、链表3、我的建议五、课后作业六、版权声明 在C语言中，编写程序的时候不能确定内存的大小，希望程序在运行的过程中根据数据量的大小动态的分配内存。动态内存管理，就是指在程序运行过程中动态的申请和释放内存空间。 C语言允许程序动态管理内存，...
c语言动态内存管理
mxrrr_sunshine的博客
02-05 246
malloc函数原型： void* malloc（size_t size） 如果开辟成功，则返回一个指向开辟好空间的指针。 如果开辟失败，则返回一个NULL指针。 返回值的类型是void*，所以malloc函数并不知道开辟空间的类型，具体在使用时由使用者决定。 如果参数size为0，malloc函数的行为是标准未定义的，由编译器决定。 因此，在使用malloc函数时，对返回值一点要做检查。 既然
c语言篇（动态内存管理）
小马同学的博客
12-10 5118
动态内存管理，很重要的一篇文章，看完这篇让你深入理解动态内存的设置，和避免开辟的时候出现的一些问题！！！！
C语言——动态内存管理
m0_64607843的博客
04-08 554
快来学习动态内存操作，对C语言更进一步了解，绝对大有裨益
C语言动态内存管理笔记
03-09
个人学习总结
连续动态内存管理模拟实现
05-15
动态内存管理允许程序在运行时请求和释放内存，提高了程序的灵活性。本项目关注的是连续动态内存管理，具体实现了一个基于“首次适应算法”的模拟器，用于64MB内存的分配与管理。 动态内存管理的核心目标是有效地...
c语言动态内存分配知识点及实例
12-20
在C语言中，动态内存分配是一项重要的编程技巧，它允许程序员在程序运行时根据需要分配内存，而不是在编译期间预设固定...然而，动态内存管理也需要小心谨慎，防止出现常见的动态内存错误，确保程序的健壮性和可靠性。
C 语言中 & 符号的两种用途
m0_46398975的博客
09-23 405
C 语言中 `&` 符号的两种用途
网站建设中常见的网站后台开发语言有哪几种，各自优缺点都是什么？
2301_80154636的博客
09-24 1755
总的来说，每种语言都有其特定的优势和局限，选择哪种语言取决于项目需求、团队技能和预期的维护成本等多种因素。理解这些语言的核心特性和适用场景可以帮助开发者做出更明智的选择，从而有效提升项目的成功率和开发效率。这些语言各有其独特的优缺点，适用于不同的开发场景和需求。市场上常见的网站后台开发语言有。
AIGC学习笔记—minimind详解+训练+推理
m0_56569131的博客
09-27 281
这个开源项目是带我的一个导师，推荐我看的，记录一下整个过程，总结一下收获。这个项目的slogan是“大道至简”，确实很简。作者说是这个项目为了帮助初学者快速入门大语言模型（LLM），通过从零开始训练一个仅26MB的微型语言模型MiniMind，最快可在3小时内完成。降低学习LLM的门槛，让更多人能够轻松上手。MiniMind极其轻量，约为GPT-3的1/7000，适合普通个人GPU进行快速推理和训练。
H.264学习笔记
zfenggo的博客
09-26 827
H.264凭借其出色的压缩效率、灵活的编码方式以及高质量的视频表现，成为了现代视频技术的核心标准之一。它不仅减少了存储需求，还提高了流媒体和实时视频传输的可行性。对于从高清到超高清视频，H.264的编码能力仍然广泛适用。H.264的帧结构设计（I帧、P帧和B帧）极大地提高了视频编码的压缩效率。I帧保存完整的图像信息，P帧通过参考之前的帧减少冗余数据，而B帧则通过双向参考提供进一步的压缩优势。这种帧间的协同工作大幅降低了带宽需求和存储成本，同时保持了视频的高质量。NALU头。
江科大笔记—LED闪烁& LED流水灯& 蜂鸣器
m0_62005595的博客
09-28 461
LED闪烁& LED流水灯& 蜂鸣器
React学习笔记（2.0）
mez_Blog的博客
09-26 473
本质：和普通JS变量不同的是，状态变量一旦发生变化组件的视图UI也会跟着发生变化（数据驱动视图），可以类比与vue中的响应式。这里的e就是一个类似原生的事件e，并不是真正的原生事件e,如果要使用原生事件e，需要使用 e.nativeEvent。在React中，一个组件就是首字母大写的函数，内部存放了组件的逻辑和视图UI，渲染组件只需要把组件当成标签书写即可。概念：一个组件就是用户界面的一部分，他可以有自己的逻辑和外观，组件之间可以相互嵌套，也可以复用多次。在css文件中定义样式，然后在引入使用。
Elasticsearch学习笔记(2）
m0_74293254的博客
09-28 1072
创建索引: 使用 PUT 请求来定义索引及其映射。创建文档: 使用 POST 请求将数据添加到索引。读取文档: 使用 GET 请求获取特定文档。更新文档: 使用 POST 加上 _update 操作来修改现有文档。删除文档: 使用 DELETE 请求删除指定文档。删除索引: 使用 DELETE 请求删除整个索引。请求方式：POST请求格式：/{索引库名}/_doc/文档id示例：POST /my_index/_doc/1 { "field": "value" }
Coursera_ Algorithms I 学习笔记：Module_3_Analysis_of_Algorithm_Introduction
最新发布
approximately_的博客
09-29 1138
Coursera_ Algorithms I 学习笔记：Module_3_Analysis_of_Algorithm_Introduction
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值