动态内存管理

最新推荐文章于 2024-09-22 10:47:56 发布
最新推荐文章于 2024-09-22 10:47:56 发布
阅读量626 收藏
点赞数 3
文章标签： c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_74828161/article/details/129893050
版权

 

目录

一：动态内存分配的原因

二：动态内存函数

1.malloc --- 动态内存分配

2.free --- 释放内存空间

3.calloc --- 动态内存分配并做初始化

4.realloc --- 动态内存调整

 三：常见的动态内存错误

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

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

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

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

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

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

 四：练习

 五：柔性数组

 1.特点

2.使用

3.优势

一：动态内存分配的原因

int a = 20;//开辟 4 个字节（栈区）
char arr[10] = { 0 };//开辟 10 个字节的连续空间（栈区）

 上述开辟空间的方式的特点：

<1>:空间开辟大小是固定的

<2>:数组在申明的时候，必须指定数组的长度，它所需要的内存在编译时分配。

如同静态版的通讯录，当期达到最大值时，就无法继续进行下去，此时，需要进行动态内存开辟。

二：动态内存函数

1.malloc --- 动态内存分配

 如果开辟成功，则返回一个指向开辟好空间的指针。
如果开辟失败，则返回一个NULL指针，因此malloc的返回值一定要做检查。

 

返回值的类型是 void* ，所以malloc函数并不知道开辟空间的类型，具体在使用的时候使用者自己来决定。
如果参数 size 为0，malloc的行为是标准是未定义的，取决于编译器。

#include<stdio.h>
#include<stdlib.h>
#include<errno.h>
#include<string.h>
int main()
{
	//开辟空间
	int* p = (int*)malloc(20);
	//判断空间是否开辟成功
    if (p == NULL)
	{
		printf("malloc: %s\n", strerror(errno));
		return 1;//结束程序
	}
	else
	{
		//使用
		int i = 0;
		for (i = 0; i < 5; i++)
		{
			*(p + i) = i + 1;
		}
		for (i = 0; i < 5; i++)
		{
			printf("%d ", *(p + i));
		}
	}
	printf("\n");
	//释放空间

	return 0;
}

 在上述代码中用到了 --- strerror

 errno

 效果为：

 

 在调试过程中，开辟空间成功后，其初始化的值为：

 使用开辟的空间后为：

 此时，如果后续再次使用指针 p ，p 即为野指针。

野指针就是指针指向的位置是不可知的（随机的、不正确的、没有明确限制的）指针变量在定义时如果未初始化，其值是随机的，指针变量的值是别的变量的地址，意味着指针指向了一个地址是不确定的变量，此时去解引用就是去访问了一个不确定的地址，所以结果是不可知的。

 所以动态内存分配的空间，需要释放掉，需要使用 free 函数。

2.free --- 释放内存空间

void free ( void* memblock);

如果参数 memblock 指向的空间不是动态开辟的，那free函数的行为是未定义的。
如果参数 memblock 是NULL指针，则函数什么事都不做。

即对上述代码进行优化 --- 增添释放空间

#include<stdio.h>
#include<stdlib.h>
#include<errno.h>
#include<string.h>
int main()
{
	//开辟空间
	int* p = (int*)malloc(20);
	//判断空间是否开辟成功
    if (p == NULL)
	{
		printf("malloc: %s\n", strerror(errno));
		return 1;//结束程序
	}
	else
	{
		//使用
		int i = 0;
		for (i = 0; i < 5; i++)
		{
			*(p + i) = i + 1;
		}
		for (i = 0; i < 5; i++)
		{
			printf("%d ", *(p + i));
		}
	}
	printf("\n");
	//释放空间
	free(p);
	p = NULL;
	return 0;
}

 释放开辟空间后为：

3.calloc --- 动态内存分配并做初始化

函数的功能是为 num 个大小为 size 的元素开辟一块空间，并且把空间的每个字节初始化0。与函数 malloc 的区别只在于 calloc 会在返回地址之前把申请的空间的每个字节初始化为0。

#include<stdio.h>
#include<stdlib.h>
#include<errno.h>
#include<string.h>
int main()
{
	//开辟空间
	int* p = (int*)calloc(5,sizeof(int));
	//判断空间是否开辟成功
	if (p == NULL)
	{
		printf("malloc: %s\n", strerror(errno));
		return 1;//结束程序
	}
	else
	{
		//使用
		int i = 0;
		for (i = 0; i < 5; i++)
		{
			*(p + i) = i + 1;
		}
		for (i = 0; i < 5; i++)
		{
			printf("%d ", *(p + i));
		}
	}
	//printf("\n");
	//释放空间
	free(p);
	p = NULL;
	return 0;
}

 效果为：

 开辟空间成功，其初始化值为0：

 使用开辟空间后为：

4.realloc --- 动态内存调整

 realloc

void* realloc (void* ptr, size_t size);
ptr 是要调整的内存地址
size 调整之后新大小
返回值为调整之后的内存起始位置。
这个函数调整原内存空间大小的基础上，还会将原来内存中的数据移动到新的空间。realloc在调整内存空间的是存在两种情况：
情况1：原有空间之后有足够大的空间
情况2：原有空间之后没有足够大的空间

 realloc函数的出现让动态内存管理更加灵活。
有时会我们发现过去申请的空间太小了，有时候我们又会觉得申请的空间过大了，那为了合理的时候内存，我们一定会对内存的大小做灵活的调整。那 realloc 函数就可以做到对动态开辟内存大小的调整。

 动态内存开辟失败时：

#include<stdio.h>
#include<stdlib.h>
#include<errno.h>
#include<string.h>
int main()
{
	//开辟空间
	int* p = (int*)malloc(20);
	//判断空间是否开辟成功
    if (p == NULL)
	{
		printf("malloc: %s\n", strerror(errno));
		return 1;//结束程序
	}
	else
	{
		//使用--- 所给空间不够，需要进行扩增
		int* ptr = (int*)realloc(p, 40);
		if (ptr == NULL)
		{
			printf("realloc: %s\n", strerror(errno));
			return 1;
		}
		else
		{
			p = ptr;
			int i = 0;
			for (i = 0; i < 10; i++)
			{
				*(p + i) = i + 1;
			}
			for (i = 0; i < 10; i++)
			{
				printf("%d ", *(p + i));
			}
		}
	}
	printf("\n");
	//释放空间
	free(p);
	p = NULL;
	return 0;
}

 效果为：

 三：常见的动态内存错误

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

#include<stdio.h>
int main()
{
	int* p = (int*)malloc(20);
	//可能会出现对NULL指针的解引用操作
	//要判断malloc的返回值
	int i = 0;
	for (i = 0; i < 5; i++)
	{
		p[i] = i;
	}
	for (i = 0; i < 5; i++)
	{
		printf("%d ", p[i]);
	}
	free(p);
	p = NULL;
	return 0;
}

 

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

#include<stdio.h>
#include<stdlib.h>
#include<errno.h>
#include<string.h>
int main()
{
	int* p = (int*)malloc(20);
	if (p == NULL)
	{
		printf("malloc: %s\n", strerror(errno));
		return 1;//结束程序
	}
	else
	{
		//使用
		int i = 0;
		for (i = 0; i <10; i++)
		{
			*(p + i) = i + 1;
		}	
	}
	return 0;
}

 

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

#include<stdio.h>
int main()
{
	int arr[5] = { 0,1,2,3,4 };
	int* p = arr;
	//.....
	free(p);
	p = NULL;
	return 0;
}

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

#include<stdio.h>
int main()
{
	int* p = (int*)malloc(20);
	if (p == NULL)
	{
		printf("malloc: %s\n", strerror(errno));
		return 1;//结束程序
	}
	//[1]  [2]  [3]  [ ]  [ ] 
	int i = 0;
	for (i = 0; i < 3; i++)
	{
		*p = i + 1;
		p++;
	}
	//当上述过程结束后，指针 p 指向下标为 3 的位置。
	
	//释放
	free(p);
	p = NULL;
	return 0;
}

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

 

#include<stdio.h>
int main()
{
	int* p = (int*)malloc(20);
	if (p == NULL)
	{
		printf("malloc: %s\n", strerror(errno));
		return 1;//结束程序
	}
	//释放
	free(p);
	p= NULL;

	//.....
	//释放
	free(p);
	p = NULL;
	return 0;
}

 将指针 p 及时置为空指针后：

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

malloc  /  calloc  /  realloc

所申请的空间，如果不想使用，需要 free 释放

如果不使用 free 释放：程序结束之后，也会被操作系统回收。

                                     程序也没有结束，内存泄露。

#include<stdio.h>
void test()
{
	int* p = (int*)malloc(20);
}
int main()
{
	test();
	//无法找到 p 的地址，造成内存泄漏
	return 0;
}

 四：练习

1.

void GetMemory(char *p)
{
     p = (char *)malloc(100);
}
void Test(void)
{
     char *str = NULL;
     GetMemory(str);
     strcpy(str, "hello world");
     printf(str);
}

<1>: 调用GetMemory函数的时候，str的传参为值传递，p是str的临时拷贝，所以在GetMemory函数内部讲动态开辟空间的地址存放在p中的时候，不会影响str。所以GetMemory函数返回之后，str中依然是NULL指针。strcpy函数就会调用失败，原因是对NULL的解引用操作，程序会崩溃。

<2>:GetMemory函数内容malloc申请的空间没有机会释放，造成了内存泄漏。

 2.

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

 返回栈空间地址的问题

GetMemory函数内部创建的数组是临时的，虽然返回了数组的其实地址给了str，但数组的内存处理GetMemory函数就被回收了，而str依然保存了数组的起始地址，这时如果使用str，str就是野指针。

 3.

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

申请的空间，没有释放，会造成内存泄漏。

释放置为空指针。

 4.

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

  str 已经被释放掉了，后续使用了str，构成了非法访问。

 五：柔性数组

 1.特点

<1>:结构中的柔性数组成员前面必须至少一个其他成员。

 

<2>: sizeof 返回的这种结构大小不包括柔性数组的内存。

#include<stdio.h>
struct S
{
	int n;
	char c;
	int arr[0];//柔性数组成员  
	//int arr[];//与上述等价
};
int main()
{
	printf("%d\n", sizeof(struct S));
	return 0;
}

 

<3>: 包含柔性数组成员的结构用malloc ()函数进行内存的动态分配，并且分配的内存应该大于结构的大小，以适应柔性数组的预期大小。

 

#include<stdio.h>
#include<stdlib.h>
#include<errno.h>
#include<string.h>
struct S
{
	int n;
	char c;
	int arr[0];//柔性数组成员  
	//int arr[];//与上述相同
};
int main()
{
	//                                       8        + 10 * 4  = 48
	struct S* ps = (struct S*)malloc(sizeof(struct S) + 10*sizeof(int));
	if (ps == NULL)
	{
		printf("%s\n", strerror(errno));
		return 1;
	}
	//使用
	ps->n = 100;
	ps->c = 'q';
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		ps->arr[i] = i;
	}
	for (i = 0; i < 10; i++)
	{
		printf("%d\n", ps->arr[i]);
	}
	//调整arr数组的大小
	struct S* ptr = (struct S*)realloc(ps, sizeof(struct S) + 20 * sizeof(int));
	if (ptr == NULL)
	{
 printf("realloc: %s\n", strerror(errno));
	return 1;
	}
	else
	{
		//使用
		for (i = 0; i < 20; i++)
		{
			ps->arr[i] = i;
		}
		for (i = 0; i < 20; i++)
		{
			printf("%d ", ps->arr[i]);
		}
	}
	//释放
	free(ps);
	ps = NULL;
	return 0;
}

2.使用

struct S
{
	int n;
	char c;
	int* arr;
};
int main()
{
	struct S* ptr = (struct S*)malloc(sizeof(struct S));
	if (ptr == NULL)
	{
		printf("%s\n", strerror(errno));
		return 1;
	}
	int* p = (int*)malloc(sizeof(int) * 10);
	if (p == NULL)
	{
		perror("malloc2");
		return 1;
	}
	else
	{
		ptr->arr = p;
	}
	//使用
	ptr->n = 100;
	ptr->c = 'q';
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		ptr->arr[i] = i + 1;
	}
	for (i = 0; i < 10; i++)
	{
		printf("%d ", ptr->arr[i]);
	}
	//如果空间不够，可以进行空间的调整
p=realloc(ptr->arr, 20 * sizeof(int));
if (p == NULL)
{
	perror("realloc");
	return 1;
	}
else
{
	ptr->arr = p;
	//使用
}
   //释放
free(ptr->arr);
ptr->arr = NULL;
free(ptr);
p = NULL;
	return 0;
}

 

3.优势

 上述 1 中为第一个 --- malloc 一次，free 一次 --- 容易维护空间，不易出错

2 为第二个 --- malloc 两次，free 两次 --- 维护难度大，容易出错

 第一个好处是：方便内存释放
如果我们的代码是在一个给别人用的函数中，你在里面做了二次内存分配，并把整个结构体返回给用户。用户调用free可以释放结构体，但是用户并不知道这个结构体内的成员也需要free，所以你不能指望用户来发现这个事。所以，如果我们把结构体的内存以及其成员要的内存一次性分配好了，并返回给用户一个结构体指针，用户做一次free就可以把所有的内存也给释放掉。

第二个好处是：这样有利于访问速度.
连续的内存有益于提高访问速度，也有益于减少内存碎片。（其实，我个人觉得也没多高了，反正你跑不了要用做偏移量的加法来寻址）

摘人参果
关注
深入详解C/C++动态内存管理
dvlinker的技术专栏
07-19 1万+
本文详细讲述了C/C++动态内存管理方面的内容，并具体阐述了几类常见的动态内存异常，以供大家借鉴或参考！
C语言：动态内存管理
2401_86551514的博客
08-26 1439
当是情况2的时候，原有空间之后没有足够多的空间时，扩展的方法是：在堆空间上另找⼀个合适大小的连续空间来使用，这样函数返回的是⼀个新的内存地址。当是情况1的时候，要扩展内存就直接原有内存之后直接追加空间，原来空间的数据不发生变化。C语言还提供了⼀个函数叫 calloc ， calloc 函数也用来动态内存分配。本篇关于动态内存管理的内容就到这里了，希望对各位有帮助，如果有错欢迎指出。由于上述的两种情况，realloc函数的使用就要注意⼀些。
浅谈C语言动态内存管理
X_Mrjw的博客
06-24 456
目录为什么存在动态内存分配动态内存函数的介绍mallocfreecallocrealloc常见的动态内存错误 为什么存在动态内存分配 动态内存函数的介绍 malloc free calloc realloc 常见的动态内存错误
动态内存的管理
qq_61514490的博客
03-20 1108
前言： 　　通常我们使用数组的时候：必须提前用一个常量来指定数组的长度，同时它的内存空间在编译的时候就已经被分配了。但是有时候数组的长度只有在运行的时候才能知道。因此，一种简单的解决方案就是提前申请一块较大的数组，可以容纳可能出现的最多的元素； 　　使用这种放的的优点就是非常简单；但是也存在很大的缺点： 1、人为因素太大，如果元素数量超过声明的长度，就会发生数组越界，避免的方法就是在声明大一点，很浪费内存； 2、如果实际使用的元素比较少的话，就会有大量的内存被浪费掉...
连续动态内存管理模拟实现
05-15
动态内存管理允许程序在运行时请求和释放内存，提高了程序的灵活性。本项目关注的是连续动态内存管理，具体实现了一个基于“首次适应算法”的模拟器，用于64MB内存的分配与管理。 动态内存管理的核心目标是有效地...
【物联网操作系统】LiteOS内存管理详解：从静态到动态内存管理的优化与应用
最新发布
04-28
文章详细介绍了LiteOS内存管理的原理，包括静态和动态内存管理。静态内存管理通过预分配固定大小的内存块，适用于固定大小的数据处理，如传感器数据存储；动态内存管理则根据实际需求灵活分配和释放内存，适用于数据...
C/C++动态内存管理
如无必要，勿增实体。
09-22 1402
C/C++中的动态内存管理是指在程序运行时，根据需要动态地分配和释放内存空间。这种管理方式主要通过堆（Heap）内存来实现，与栈（Stack）内存不同，堆内存的分配和释放不由编译器自动管理，而是需要程序员手动控制。以下是C/C++动态内存管理的详细介绍：在C++中，动态内存分配主要通过和操作符来实现，而在C语言中，则使用、、和等函数。 calloc: 用于分配多个相同大小的内存块，并将其初始化为零。 realloc: 用于重新分配已分配的内存块的大小。 free: 用于释放之前通过、或分配的内
~动态内存管理~
眼与泪的诀别的博客
08-16 377
动态内存管理
自动管理内存碎片的动态内存管理技术
动态内存管理是计算机科学中的一个重要概念，特别是在编程领域中，它允许程序在运行时动态地申请和释放内存。动态内存管理有别于静态内存管理，后者在编译时就确定了内存的分配和使用。动态内存管理的优点和细节可以...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值