纯净、安全、绿色的下载网站

首页|软件分类|下载排行|最新软件|IT学院

当前位置:首页IT学院IT技术

C语言 动态内存管理 C语言动态内存管理分析总结

Ersansui   2021-11-20 我要评论
想了解C语言动态内存管理分析总结的相关内容吗Ersansui在本文为您仔细讲解C语言 动态内存管理的相关知识和一些Code实例欢迎阅读和指正我们先划重点:C语言,动态内存管理,C语言,内存管理下面大家一起来学习吧。

什么是动态内存分配

我们都知道在C语言中定义变量的时候系统就会为这个变量分配内存空间而且这个空间是在栈上开辟的这种方式就会有两个特点。

  • 开辟的空间大小是固定的
  • 数组在申明的时候必须要指定数组的长度以方便为其分配内存大小

但是这种方法并不能满足我们在开发中的需要因为有时候我们需要开辟的空间大小是在程序巡行的过程中才能知道要开辟多大的。

这时候数组的这种开辟方式就不能满足了因此也就有了动态内存分配的需要。

而动态内存分配会根据需求而分配空间大小是可以变化的并且是在堆区上分配空间而堆区的内存空间大小一半都会比栈区大。

动态内存函数的介绍

需要需要动态内存管理需要了解C语言中一下的几个函数。

统一说明:一下的函数都包含在<stdlib.h>中。

free

void free (void* ptr);

为了后面可以进行代码演示这里先介绍free这个函数。

我们在使用相关函数动态开辟了内存空间之后函数会返回这片空间的的首地址给使用者当使用者用完空间之后需要手动对这片空间进行释放把内存空间还给操作系统。

如果参数 ptr 指向的空间不是动态开辟的那free函数的行为是未定义的。
如果参数 ptr 是NULL指针则函数什么事都不做。
释放的空间是ptr所指向的那块内存空间

上面的第一种情况有可能编译器会报错。

如果我们仅仅只是开辟空间使用而不释放的话会占用内存空间资源造成内存泄漏影响性能。

因此我们需要养成用完就释放的好习惯。

malloc

void* malloc (size_t size);

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

连续可用的特点就像数组一样。

如果开辟成功则返回一个指向开辟好空间的指针。
如果开辟失败则返回一个NULL指针。
返回值的类型是 void* 因此使用者需要根据自己的需求来转化使用。
如果参数size大小为0malloc 的行为是标志没有规定的取决于编译器。

size的大小是按照字节为单位的。

#include <stdio.h>

int main()
{
	//代码1
	int num = 0;
	scanf("%d", &num);
	int arr[num] = { 0 };

	//代码2
	int* ptr = NULL;
	ptr = (int*)malloc(num * sizeof(int));
	if (NULL != ptr)//判断ptr指针是否为空
	{
		int i = 0;
		for (i = 0; i < num; i++)
		{
			*(ptr + i) = 0;
		}
	}

	free(ptr);//释放ptr所指向的动态内存
	ptr = NULL;//是否有必要?
	return 0;
}

上面的代码就是malloc函数的基本使用过程在代码1中这样的使用方法一般来说编译器是不支持的而第二种方法也就是动态内存开辟的方法编译器就支持。

在最后记得要把ptr所指向的空间给释放掉。

这个时候ptr种存储的仍然是那块空间的地址这就称为了野指针所以我们还要把ptr置空。

calloc

与malloc类相似的C语言还提供了另外一个动态开辟内存的函数那就是calloc。

void* calloc (size_t num, size_t size);

需要注意的是这个函数的参数有所不同第一个参数num是用来确定你开辟的连续空间是用来存放多少个元素的而第二个参数size表示的是一个元素占用多少的字节。

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

所以如果我们需要在动态开辟内存的时候进行初始化我们可以使用calloc这个函数。

我们可以通过调试的监视窗口来查看这个函数在开辟空间的时候是否帮我们初始化。

#include <stdlib.h>


int main()
{
	int* p = (int*)calloc(10, sizeof(int));
	if (NULL != p)
	{
		//使用空间
	}
	free(p);
	p = NULL;
	return 0;
}

realloc

有时候我们会发现哪怕是使用上面的动态内存管理的函数也会有不方便的时候。我们可能会因为空间申请小了不够用而去扩容但是如果我们使用上面两个函数去开辟更大的空间的时候之前的数据拷贝过来新开辟的更大的空间又很麻烦。

这个时候我们就可以使用realloc了。

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

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

在realloc函数使用的时候会出现两种情况:

原有的空间之后还有足够的空间

如果原来的内存空间之后还有足够的空间来满足新的大小这时候就会直接对原来的空间进行扩容原来空间的数据不会发生变化。

原有的空间之后没有足够的空间

如果原来的空间之后没有足够的空间满足需要就会在内存区域中开辟一片能够满足新的大小需要的连续空间并且把原来空间的数据拷贝的新的空间中释放原来的空间返回新的地址。

#include <stdio.h>

int main()
{
	int* ptr = (int*)malloc(100);
	if (ptr != NULL)
	{
		//业务处理
	}
	else
	{
		exit(EXIT_FAILURE);
	}

	//扩展容量

	//代码1
	ptr = (int*)realloc(ptr, 1000);
	
	//代码2
	int* p = NULL;
	p = realloc(ptr, 1000);
	if (p != NULL)
	{
		ptr = p;
	}
	//业务处理
	free(ptr);
	return 0;
}

上述代码种代码1的做法是不安全的如果我们扩容失败后会返回空指针这个时候ptr接收了空指针就会造成ptr原来的那块空间的数据丢失并且造成内存泄漏。

因此一般我们都需要像代码2那样先用一个临时的指针变量接收返回值并且在判定不为空指针后再复制给ptr。

动态内存管理中常见的错误

我们在使上面这些函数的时候会经常出现一下的错误。

对NULL指针的解引用操作

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

	//没有进行判空就直接使用空间
	*p = 20;//如果p的值是NULL就会有问题
	free(p);
}

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

void test()
{
	int i = 0;
	int* p = (int*)malloc(10 * sizeof(int));
	if (NULL == p)
	{
		exit(EXIT_FAILURE);
	}
	for (i = 0; i <= 10; i++)
	{
		*(p + i) = i;//当i是10的时候越界访问
	}
	free(p);
}

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

void test()
{
int a = 10;
int *p = &a;
free(p);
}

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

void test()
{
	int* p = (int*)malloc(100);
	p++;
	free(p);//p不再指向动态内存的起始位置
	//这样做一般编译器也会报错的
}

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

void test()
{
	int* p = (int*)malloc(100);
	free(p);
	free(p);//重复释放一般来说编译器会报错
}

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

void test()
{
	int* p = (int*)malloc(100);
	if (NULL != p)
	{
		*p = 20;
	}
}
int main()
{
	test();
	while (1);
}

我们在使用上面的函数的时候一定要小心避免上面的这些错误。

一些经典的笔试题

题目1

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

上面的代码有错在开辟空间后没有进行判空操作并且在调用GetMemory函数的时候传入的形参是str的一份临时拷贝在函数内部p的改变不会改变main中的str所以在GetMemory返回的时候p所指向的空间会泄漏并且在strcpy中造成了对空指针的解引用操作。

题目2

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

这段代码也是错误的在GetMemory中不是用动态内存管理的函数来开辟空间而是使用数组的开辟方式这样的开辟方式会在栈区开辟空间当GetMemory函数调用完成的时候就会销毁开辟的数组这时候外面的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);
}

上面的代码在使用完成动态开辟的空间后没有进行判空操作并且没有进行内存释放造成了内存泄漏。

题目4

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

上面的代码提前释放了空间后面又使用指针对已经释放的空间进行操作这是非法的释放后指向这块空间的指针就是野指针需要进行置空。

柔性数组

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

例如:

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

如果有的编译器报错可以改成下面这个样子

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

柔性数组的特点

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

例如:

//code1
typedef struct st_type
{
	int i;
	int a[0];//柔性数组成员
}type_a;
printf("%d\n", sizeof(type_a));//输出的是4
typedef struct st_type
{
	int i;
	int a[0];//柔性数组成员
}type_a;

//代码1
int i = 0;
type_a* p = (type_a*)malloc(sizeof(type_a) + 100 * sizeof(int));
//业务处理
p->i = 100;
for (i = 0; i < 100; i++)
{
	p->a[i] = i;
}
free(p);

这样柔性数组成员a相当于获得了100个整型元素的连续空间。

柔性数组的优势

上面的代码也可以这样设计:

//代码2
typedef struct st_type
{
	int i; 
	int* p_a;
}type_a;

type_a* p = (type_a*)malloc(sizeof(type_a));
p->i = 100;

p->p_a = (int*)malloc(p->i * sizeof(int));

//业务处理
for (i = 0; i < 100; i++)
{
	p->p_a[i] = i;
}

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

上述 代码1 和 代码2 可以完成同样的功能但是 方法1 的实现有两个好处:

  • 方便内存释放
  • 这样有利于访问速度

相关文章

猜您喜欢

网友评论

Copyright 2020 www.tdogsoftware.com 【零度软件园】 版权所有 软件发布

声明:所有软件和文章来自软件开发商或者作者 如有异议 请与本站联系 点此查看联系方式