C语言--动态内存管理

最新推荐文章于 2024-10-17 17:21:13 发布
最新推荐文章于 2024-10-17 17:21:13 发布
阅读量174 收藏
点赞数
文章标签： c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_32780809/article/details/129123931
版权

目录

一、动态内存分配的意义

我们已经掌握的内存开辟方式有：
int val = 20; 在栈空间上开辟4个字节
char arr[10] = {0}; 在栈空间上开辟10个字节的连续空间
但是上述的开辟空间的方式有两个特点：

  1. 空间开辟大小是固定的
  2. 数组在申明的时候，必须指定数组的长度，它所需要的内存在编译时分配
    但是对于空间的需求，不仅仅是上述的情况，有时候我们需要的空间大小在程序运行的时候才能知道

那数组的编译时开辟空间的方式就不能满足了，这时候就只能试试动态开辟了。
在这里插入图片描述

二、动态内存函数介绍

1.malloc（开辟内存块）

  1. void* malloc(size_t size)
  2. 向内存申请一块连续可用的空间，并放回指向这块空间的指针
  3. 如果开辟成功，则返回一个只想开辟好这块空间的指针
  4. 如果开辟失败，则返回一个NULL指针，因为malloc的返回值一定要做检查
  5. 返回值的类型为void*，所以malloc函数并不知道开辟空间的类型，具体在使用的时候使用者自己来决定
  6. 如果参数size为0，mallloc的行为是标准未定义的，取决于编译器
#include<stdio.h>
#inlcude<stdlib.h>
#include<error>
int main()
{
	像内存申请10个整型的空间
	int* p = (int*)malloc(40);
	if(p == NULL)
	打印错误原因的一个方式
		printf("%s\n",strerror(errno));
	else
	{
	正常使用空间
		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
	p = NULL;
	return 0;
}

2.calloc

  1. void* calloc(size_t num,size_t size)
  2. num代表元素的个数，size代表字节
  3. 为num个大小为size的元素开辟一块空间，并且把每个字节初始化为0
  4. 向内存申请一块连续可用的空间，并返回指向这块空间的指针
  5. 如果开辟成功，则返回一个指向开辟好这块空间的指针
  6. 如果开辟失败，则返回一个NULL指针，因此calloc的返回值一定要做检查
  7. 返回值的类型是void*，所以calloc函数并不直到开辟空间的类型，具体在使用的时候使用者自己来决定
  8. 如果参数size为0，calloc的行为是标准未定义的，取决于编译器
  9. malloc和calloc的区别在于calloc会在返回地址前把申请的空间的每个字节初始化为0
#include<stdio.h>
#inlcude<stdlib.h>
#include<error>
int main()
{
	像内存申请10个整型的空间，并全部初始化为0
	int* p = (int*)calloc(40);
	if(p == NULL)
		打印错误原因的一个方式
		printf("%s\n",strerror(errno));
	else
	{
		正常使用空间
		int i = 0;
		for(i = 0;i < 10;i++)
		{
			printf("%d ",*(p+i));
			打印结果全为 0
		}
	}
	当动态申请的空间不再使用的时候
	就应该还给操作系统
	free(p);
	释放内存后，p的地址依然没有变，设置为NULL
	p = NULL;
	return 0;
}

3.realloc

realloc函数的出现让动态内存管理更加灵活
realloc函数可以做到对动态开辟内存大小的调整

  1. void* realloc(void* ptr,size_t size)
  2. ptr是要调整的内存地址，size是调整之后的新大小
  3. 返回值为调整之后的内存起始位置
  4. 这个函数在调整原内存空间大小的基础上，还会将内存中的数据移动到新的空间
  5. 开辟失败，返回NULL
  6. 如果p指向的空间之后有足够的内存空间可以追加，则直接追加后返回p
  7. 如果p指向的空间之后没有足够的内存空间可以追加，则realloc函数会重新找一个新的内存区域，开辟一块新的满足需求的空间，并且把原来内存的数据拷贝过来，释放旧的内存空间，最后返回新开辟的内存空间地址
  8. 得用一个新的变量来接收realloc函数的返回值
  9. ptr是NULL，则默认使用了malloc，可以直接使用realloc追加
    在这里插入图片描述
int main()
{
	int* p = (int*)malloc(20);
	if(p == NULL)
	{
		printf("%s\n",strerror(errno));
	}
	else
	{
		int i = 0;
		for(i = 0;i < 5;i++)
		{
			*(p+i) = i;
		}
	}
这只是在使用malloc开辟的20个字节空间
假设这里，20个字节不能满足使用了
希望能够有40个字节的空间
这里就可以使用realloc来调整动态开辟的内存
	int* p2 = realloc(p,40);

	p = realloc(p,40);
不能赋值到原来的地址上
具体原因看p的注意事项
	int* ptr = realloc(p,INT_MAX)
	if(ptr != NULL)        如果开辟成功
	防止开辟失败把p给改掉
	{
		p = ptr;
		int i = 0;
		for(i = 0;i < 5;i++)
		{
			*(p+i) = i;
		}
	}

	int i = 0;
	for(i = 5;i < 10;i++)
	{
		*(p2+1) = i;
	}
	for(i = 0;i < 10; i++)
	{
		printf("%d ",*(p2 + i);
		打印结果为0 1 2 3 4 5 6 7 8 9
	}
	释放内存
	free(p)
	p = NULL;
	return 0;
}

可以用realloc直接开辟空间
int main()
{
	int* p =realloc(NULL,40);	等价于malloc(40)
	return 0;
}

4.free（释放动态内存空间）

  1. void free(void* ptr)
  2. 释放动态函数开辟的内存
  3. 如果参数ptr指向的空间不是动态开辟的，那free函数的行为是未定义的
  4. 如果参数ptr是NULL指针，则函数什么事情都不会做

三、常见的动态内存错误

1.对NULL指针的解引用操作

int main()
{
	int* p = (int*)malloc(40);
	万一malloc失败了，p就被赋值NULL
	因此加一个判断条件
	if(p == NULL)
	{
		return 0;
	}
	else
	{
		int i = 0;
		for(i = 0;i < 10;i++)
		{
			*(p + i) = i;
		}
	free(p);
	p = NULL;
	reutrn 0;
	}
}

2.对动态内存开辟空间的越界访问

#include<stdio.h>
#include<stdlib.h>
#include<error>
int main()
{
	int* p = (int*)malloc(5 * sizeof(int));
	if (p == NULL)
	{
		return 0;
	}
	else
	{
		int i = 0;
		for (i = 0; i < 10; i++)
			//越界访问
		{
			*(p + i) = i;
		}
	}
	free(p);
	p = NULL;
	return 0;
}

3.对非动态开辟内存使用free释放

#include<stdio.h>
#include<stdlib.h>
#include<error>
int main()
{
	int a = 10;
	int* p = &a;
	*p = 20;
	free(p);
	p为栈区，而非堆区的动态内存
	p = NULL;
	return 0;
}

4.使用free释放动态内存的一部分

#include<stdio.h>
#include<stdlib.h>
#include<error>
int main()
{
	int* p = (int*)malloc(40);
	if (p == NULL)
		return 0;
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*p++ = i;
	}
	回收空间
	free(p);
	p不指向原来的地址了
	p = NULL;
	return 0;
}

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

#include<stdio.h>
#include<stdlib.h>
#include<error>
int main()
{
	int* p = (int*)malloc(40);
	if (p == NULL)
		return 0;
	free(p);
	p = NULL;
	设置p为NULL就不会影响了
	每次释放完都指定为空指针就可以避免了
	……
	free(p);
	free函数对空指针不会有响应
	return 0;
}

6.动态开辟内存释放（内存泄漏）

#include<stdio.h>
#include<stdlib.h>
#include<error>
int main()
{
	while (1)
	{
		malloc(1);
		开辟空间却不进行释放回收导致内存泄漏
	}
	return 0;
}

四、程序的内存开辟

1.栈区

  1. 在执行函数时，函数内部局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放
  2. 栈内存非陪运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限
  3. 栈区主要存放运行函数而分配的局部变量、函数参数、返回数据、返回地址等
  4. 普通的局部变量时在栈区分配空间的，栈区的特点是在上面创建的变量除了作用域就销毁

2.堆区

一般由程序员分配释放，若程序员不释放，程序结束时可能由OS回收，分配方式类似于链表

3.数据段（静态区）

  1. 存放全局变量、静态数据，程序结束后由系统释放
  2. 但是被static修的变量存放在数据段（静态区），数据段的特点就是在上面创建的变量，直到程序结束才销毁

4.代码段

存放函数体（类成员函数和全局函数）的二进制编码

五、柔性数组

C99中，结构体中的最后一个元素时位置大小的数组，就叫做[柔性数组]成员

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

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

特点

  1. 结构体中的额柔性数组成员前面必须至少有一个其他成员
  2. sizeof返回的这种结构大小，不包括柔性数组的内存
  3. 包含柔性数组成员的结构用malloc()函数进行内存的动态分配，并且分配的内存应该大于结构的大小，以适应柔性数组的预期大小

malloc添加

寄存器的局部性原理，会直接从周边的数据中查找
查找不到就去cache中找，再找不到就去内存找
malloc开辟一个块新的空间，ps->arr不一定与n是连续的，可能会在内存的各个角落里
严重影响了效率
释放顺序也要注意

#include<stdio.h>
#include<stdlib.h>
struct S
{
	int n;
	int arr[]或int arr[0]; 未知大小的 - 柔性数组成员 - 数组的大小是可以调整的
};
int main()
{
	struct S s;
	printf("%d\n", sizeof(s));
	打印结果为 4
	struct S* ps = (struct S*)malloc(sizeof(struct S) + 5 * sizeof(int));
	5 * sizeof(int)是为数组arr开辟的空间
		ps->n = 100;
	int i = 0;
	for (i = 0; i < 5; i++)
	{
		ps->arr[i] = i;
	}
	sturct S* ptr = realloc(ps, 44);
	从原来的24个字节增加到44个字节
		if (prt != NULL)
			判断是否开辟成功
		{
			ps = ptr;
		}
	for (i = 5; i < 10; i++)
	{
		p - s->arr[i] = i;
		数组可以使用接下去开辟的空间
	}
	for (i = 0; i < 10; i++)
	{
		printf("%d ", ps->arr[i]);
	}
	free(ps);
	释放内存
		ps = NULL;
	return 0;
}
n 后面紧跟着 arr

在这里插入图片描述

realloc添加

#include<stdio.h>
#include<stdlib.h>
struct S
{
	int n;
	int* arr;
};

int main()
{
	struct S* ps = (struct S*)malloc(sizeof(strcut S));
	ps->arr = malloc(5 * sizeof(int));
	开辟5个连续整型空间
		int i = 0;
	for (i = 0; i < 5; i++)
	{
		ps->arr[i] = i;
	}
	for (i = 0; i < 5; i++)
	{
		printf("%d ", arr[i]);
	}
	int* ptr = realloc(ps->arr, 10 * sizeof(int));
	对ps->arr这个指针地址弥补开辟到10个连续整型大小
		if (ptr != NULL)
		{
			ps->arr = ptr;
		}
	for (i = 5; i < 10; i++)
	{
		ps->arr[i] = i;
	}
	for (i = 0; i < 10; i++)
	{
		printf("%d ", ps->arr[i]);
	}
	free(ps->arr);
	ps->arr = NULL;
	free(ps);
	ps = NULL;
	return 0;
}

六、练习题

1.形参陷阱

void GetMemory(char* p)
{
	p = (char*)malloc(100);
	形参变量出了函数就消失了
	尚未释放动态内存，就找不到地址了
}

void Test(void)
{
	char* str = NULL; 
	GetMemory(str);
	str是char*类型的指针变量，传过去用char*类型的指针变量接收，为传值
	如果想要传地址，应该用二级指针接收char** p,且&str，才能修改str的值
	strcpy(str,"hello,world);
	printf(str);
}

int main()
{
	Test();
	return 0;
}
1.运行代码程序会出现崩溃的现象
2.程序存在内存泄漏的问题
str以值传递的形式给p
p是GetMemory函数的形参，只能函数内部有效
等GetMemory函数返回之后，动态开辟内存尚未释放
并且无法找到，所以会造成内存泄漏

改正 1 二级指针
void GetMemorey(char** p)
{
	*p = (char*)malloc(100);
}
void Test(void)
{
	char* str = NULL;
	GetMemory(&str);
	strcpy(str,"hello world");
	printf(str);
	free(str);
	str = NULL;
}
int main()
{
	Test();
	return 0;
}

改正2 返回形参
char* GetMemorey(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;
}

2.返回栈空间地址的问题

栈区

#include<stdio.h>
#include<stdlib.h>
char* GetMemory(void)
{
	char p[] = "hello world";
	数组p局部变量一旦出了生命周期就结束
	return p;
	返回的p就是个野指针
}
void Test(void)
{
	char* str = NULL;
	str = GetMemory();
	printf(str);
	非法访问的问题，打印随机值
}
int main()
{
	Test();
	reutn 0;
}

堆区

#include<stdio.h>
#include<stdlib.h>
int* test()
{
	int* ptr = malloc(100)
	出了函数，堆区开辟的动态内存还存在
	只有通过free才能释放
	因此此代码没有问题
	return ptr;
}
int main()
{
	int* p = test();
	return 0;
}

静态区

#include<stdio.h>
#include<stdlib.h>
int* test()
{
	static int a = 10静态区，生命周期延长
	int a = 10; 栈区
	return &a;
}
int main()
{
	int* p = test();
	*p = 20;
	return 0;
}

3.内存泄漏

#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);
}
int main()
{
	Test();
	return 0;
}

4.非法访问

#include<stdio.h>
#include<stdlib.h>
void Test(void)

{
	char* str = (char*)malloc(100);
	strcpy(str, "hello");
	free(str);
	释放了还使用，非法访问内存
		free释放str指向的空间后，并不会把str置为NULL
		改正
		str = NULL;
	if (str != NULL)
	{
		strcpy(str, "world");
		把hello给覆盖了
		printf(str);
		打印world
	}
}
int main()
{
	Test();
	return 0;
}
我想玩游戏
关注
C语言进阶---动态内存管理.md
04-03
动态内存空间开辟的详细讲解
C语言-管理系统
06-24
综上所述，开发C语言-网吧管理系统涉及到的数据结构、文件操作、内存管理、函数设计、输入输出处理、错误处理、并发多线程、数据安全以及数据库接口等多个方面，这些都是C语言编程中的核心知识点。通过这样的项目...
C语言 -- 动态内存管理
m0_64364831的博客
07-25 1218
C语言 -- 动态内存管理
c语言-实现动态内存管理的库函数
pyc68的博客
01-21 1592
本篇文章介绍c语言中实现动态内存管理的库函数，比如malloc()、free()、calloc()、realloc()
C语言 - 动态内存分配
good good study, day day up!
01-26 3936
malloc calloc relloc free 动态申请内存
C语言--动态内存管理(随用随开辟，可真香)
qq_61688804的博客
03-31 6893
一，为什么有动态内存管理 通常情况下我们是如下开辟空间的： int val = 20;//在栈空间上开辟四个字节 char arr[10] = {0};//在栈空间上开辟10个字节的连续空间 但是上述的开辟空间的方式有两个特点： 1. 空间开辟大小是固定的。 2. 数组在申明的时候，必须指定数组的长度，它所需要的内存在编译时分配。 在某些情况下，空间的大小是需要实时开辟的，大小也是不一定的，所以这时候就需要用到动态内存的开辟。动态内存开辟，都是在对堆区上的空间进行操作。 二，...
C语言-动态内存管理
2201_76032321的博客
05-06 1881
malloc函数用于动态分配指定大小的内存空间。*ptr = 100;在上面的示例中，我们使用malloc函数分配了一个int类型的内存空间，并将其赋值为100。
C语言------动态内存管理
m0_69978464的博客
07-14 468
C语言---动态内存管理 正确的版本： 正确的版本：
C语言----动态内存分配（malloc calloc relloc free）超全知识点
weixin_69884785的博客
08-06 2204
C语言----动态内存分配（malloc calloc relloc free）超全知识点
C语言--------动态内存函数
m0_69978464的博客
07-13 471
C语言-----动态内存函数 malloc free calloc realloc
c语言--动态内存管理（malloc、realloc、free、calloc)
2302_81090306的博客
04-05 1434
动态内存管理（malloc、realloc、free、calloc)详解
C语言-- 图书管理系统.zip
08-11
3. 动态内存分配：理解如何使用`malloc`和`free`在运行时动态地分配和释放内存。 4. 输入/输出处理：掌握`scanf`和`printf`函数的用法，以及如何从用户那里获取输入并显示结果。 5. 控制流程：学习如何使用循环、...
03 嵌入式C语言高级---内存空间.rar
06-30
"03 嵌入式C语言高级---内存空间"这一主题，着重探讨了C语言在处理内存管理方面的高级概念，这对于理解和优化物联网设备的性能至关重要。以下是对这个主题的详细讲解： 内存空间在计算机系统中被划分为几个主要区域...
C语言-电影俱乐部会员管理系统.zip
12-02
4. **内存管理（Memory Management）**：C语言要求程序员手动管理内存，使用malloc和free等函数分配和释放内存。在会员管理系统中，可能会用到这些函数来动态地分配和释放结构体实例。 5. **输入/输出（Input/...
【C语言】文件的读写，打开与关闭
最新发布
我的我的博客
10-17 163
文件的读写这个十分便利，可以在写文件时可以通过循环来批量操作多个文件。接着，给到相应的读、写、追加等权限。再接着，操作文件内容。首先，定义文件指针。
【C语言刷力扣】1748.唯一元素的和
2301_76779875的博客
10-14 341
【C语言刷力扣】1748.唯一元素的和
【C语言刷力扣】2206.将数组划分成相等数对
2301_76779875的博客
10-14 418
【C语言刷力扣】2206.将数组划分成相等数对
结合空口分析BLE AUDIO之PAC
10年蓝牙协议软件工作经验，仅代表自己的理解，不一定正确，欢迎置评
10-14 644
结合空口分析LE AUDIO的PAC服务内容
C语言内存管理详解与内存泄漏解决
"C语言内存管理相关教程资料" 在C语言中，内存管理是程序员必须掌握的重要技能之一。它涉及到程序中变量的存储、分配和释放，对于理解和避免内存泄漏至关重要。下面将详细介绍C语言的内存管理方式。 1-1 C语言内存...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值