【C语言】动态内存管理

最新推荐文章于 2024-09-27 11:26:03 发布

心之王者716

最新推荐文章于 2024-09-27 11:26:03 发布

阅读量398

点赞数 20

分类专栏： C/C++ 文章标签： c语言 c++

本文链接：https://blog.csdn.net/lyq2632750277/article/details/127226519

版权

C/C++ 专栏收录该内容

18 篇文章 0 订阅

订阅专栏

文章目录

前言
一、动态内存函数介绍
二、常见的动态内存错误
三、柔性数组
总结

前言

在学习动态内存管理之前，我们所开辟的内存都是在栈区开辟的，而且大小的固定的，无法随意更改。在申请空间的时候我们就得知道申请空间的大小，这是非常不方便的。
这时候就只能试试动态内存开辟了。

一、动态内存函数介绍

1. malloc和free

C语言提供了一个动态内存开辟的函数：

void* malloc(size_t size);

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

如果开辟成功，则返回一个指向开辟好空间的指针。
如果开辟失败，则返回一个空指针（NULL），所以malloc的返回值要做是否为空指针的判断，以防空间申请失败。
由于该函数返回类型是void*，所以使用者在使用的时候要想好自己想申请一块什么类型的空间。
如果输入的参数size为0，这个行为在C语言标准里是未定义的，具体怎么实现取决于编译器。

有内存的开辟，但使用完之后呢，这块空间并不会自动回收，需要我们人为把这个函数给回收

C语言给我们提供了一个释放和回收内存的函数——free

void free (void* ptr);

如果参数ptr指向的空间不是动态开辟的，那free函数的行为也是标准里未定义的。
如果参数ptr是空指针，则free什么也不做。

举个例子：

#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;//将ptr置为空指针，避免造成野指针
 return 0;
}

free和malloc全都在stdio.h这个头文件中声明。

2. calloc

C语言还提供了另一个动态内存分配的函数——calloc

void calloc (size_t num, size_t size);

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

举个例子：

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

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

在这里插入图片描述

因此，如果我们需要对申请的空间进行初始化就可以用calloc函数。

3. realloc

realloc函数的出现让动态内存管理更加灵活。
我们申请的空间有时候可能大了，有时候也可能小了，这时候我们需要对内存大小进行一个合理的调整，这时候就需要用realloc函数。

函数形式如下：

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

ptr是要调整的内存地址
size是调整之后的新内存大小
返回值为调整之后新内存的起始地址
该函数在调整原内存空间大小的基础上，还会将原来内存中的数据移到新的空间。
调整内存大小有两种情况：
1.原来数据之后有足够大的空间，这时候如果需要扩展内存只需要在原有内存之后进行追加就可以了，原有空间的数据不会发生变化。
2.原来数据之后没有足够大的空间时，这时就需要在堆区上另找一块大小合适的连续空间了，这样返回就是一个新的内存空间的起始地址，realloc这么做时候会把原来的内存空间给释放掉。

在这里插入图片描述

二、常见的动态内存错误

1.对NULL指针进行解引用操作

void test()
{
 int *p = (int *)malloc(INT_MAX/4);
 *p = 20;//如果p的值是NULL，就会有问题
 p = NULL;
 free(p);
}

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

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

3.对非动态开辟的内存用free进行释放

void test()
{
 int a = 10;
 int *p = &a;
 free(p);//不能对栈区的空间进行释放
}

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

void test()
{
 int *p = (int *)malloc(100);
 p++;
 free(p);//p不再指向动态内存的起始位置，不能释放一部分空间
}

5.动态开辟内存忘记释放（内存泄露）

void test()
{
	 int *p = (int *)malloc(100);
	 if(NULL != p)
	 {
	 	*p = 20;
	 }
}
int main()
{
	 test();
	 //没有对动态开辟的内存进行释放，会造成内存泄露
	 while(1);
}

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

void test()
{
	 int *p = (int *)malloc(100);
	 free(p);
	 free(p);//重复释放
}

三、柔性数组

也许你从来没有听说过柔性数组（flexible array）这个概念，但是它确实是存在的。
C99 中，结构中的最后一个元素允许是未知大小的数组，这就叫做『柔性数组』成员。

举个例子：

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

1.柔性数组的特点

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

2.柔性数组的使用

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

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

3.柔性数组的优势

上述的代码同样可以设计成

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

int main()
{
	type_a* p = (type_a*)malloc(sizeof(type_a));
	p->i = 100;
	p->a = (int*)malloc(p->i*sizeof(int));
	
	for(i=0; i<100; i++)
	{
	 	p->a[i] = i;
	}

	free(p->a);
	p->a = NULL;
	free(p);
	p = NULL;
}