【C语言】动态内存管理

hao xiao zi

已于 2024-05-29 14:25:54 修改

阅读量729

点赞数 18

分类专栏：【C】文章标签： c语言学习方法笔记

于 2024-04-07 16:38:09 首次发布

本文链接：https://blog.csdn.net/2301_80424145/article/details/137436393

版权

【C】专栏收录该内容

12 篇文章 0 订阅

订阅专栏

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

🦴🦴为什么要存在动态开辟内存

我们已经掌握的内存开辟方式大概为以下两种

int ch = 4;//在栈区上开辟4个字节的空间
 
int arr[10];//在栈空间上开辟40个字节的连续空间

以上两种内存开辟方式的特点：

空间开辟大小是固定的
数组在申明的时候，必须指定数组的长度，数组空间一旦确定了大小不能调整

但是，当我么们不知道所需的空间要多大的时候，以上的两种内存开辟方式会造成两个弊端

如果开辟的内存空间过小，就会造成大量的数据丢失
如果开辟的内存空间过大，造成对内存空间的浪费

比如说某短视频平台在刚刚开始投入使用时，用户的数据存储在数组中，但是站在平台的角度他是不知道这个平台以后的用户数量具体会有多少，如果在定义数组长度时，给的长度过小，平台后面爆火的话，用户的数据大小就会超过给定的数组空间大小，这些多出来的数据就会丢失，造成无法挽回的损失

所以C语言引入了动态内存开辟，让程序员自己可以申请和释放空间，就可以按需要分配内存空间，比较灵活

🦴🦴动态内存开辟的函数

❗❗❗ 切记：所以动态内存开辟的函数都是在内存的堆区上开辟空间的

👁️👁️malloc和free

malloc是C语言提供的一个动态开辟内存的函数，需包含头文件 <stdlib.h>

参数 size 是要动态开辟的内存空间大小，单位是字节

返回值：

如果开辟成功：返回一个void * 的指针，指向开辟的空间的首地址

如果开辟失败：返回一个NULL(空指针)

使用：

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

int main()
{
	int* ptr = (int*)malloc(sizeof(int) * 10);//强转成我们要的数据类型
	if (ptr == NULL)//检验返回的是否为空指针
	{
		perror("malloc");
		exit(1);
	}
	for (int i = 0; i < 10; i++)
	{
		ptr[i] = i + 1;
		printf("%d ", ptr[i]);
	}
	return 0;
}

为什么开辟成功后，返回的是一个void *的指针，因为编写malloc这个函数的人，他是不知道我们要开辟这个空间来存储什么类型的数据，只有我们自己才知道要存储什么类型的数据，所以使用malloc函数，需要对返回的指针强转成我们要的类型，之后在用一个同类型的指针来接收，但是malloc函数有可能开辟空间失败，返回一个空指针，所以在使用指针前，需要判断返回的是否为空指针，时的话直接退出，避免后面对空指针解引用，造成编译错误

free 函数是用来释放我们动态开辟的内存空间的

只要是动态开辟的内存空间，使用完后都要使用free函数对其进行释放

参数 memblock 必须指向我们动态开辟的内存空间首地址
参数 memblock 为空指针则什么事情都不做
free函数不能对同一块空间就行多次释放

上面malloc函数写的使用用例还有点小瑕疵，因为没有对malloc函数开辟的内存空间进行释放

使用：

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

int main()
{
	int* ptr = (int*)malloc(sizeof(int) * 10);//强转成我们要的数据类型
	if (ptr == NULL)//检验返回的是否为空指针
	{
		perror("malloc");
		exit(1);
	}
	for (int i = 0; i < 10; i++)
	{
		ptr[i] = i + 1;
		printf("%d ", ptr[i]);
	}
    free(ptr);//只是对ptr指向的内存空间进行释放，但是ptr还保存着该空间的首地址
    ptr = NULL;//置为空指针，防止野指针
	return 0;
}

free函数只是对ptr指向的内存空间进行释放，把这个空间的使用权限归还给操作系统，但是ptr还是保存着该空间的首地址，为了防止ptr成野指针，每次释放完空间后还要将指针置为空

👁️👁️calloc

calloc是C语言提供的一个动态开辟内存的函数，需包含头文件 <stdlib.h>

calloc 是开辟一块num个size大小的动态内存空间
size 为数组中每个元素大小
num 为数组元素个数
如果开辟成功：返回一个void * 的指针，指向开辟的空间的首地址
如果开辟失败：返回一个NULL(空指针)

该函数与malloc函数大多处都相似，都需要进行类型强转，判断是否为空指针，也需要用free函数进行释放，唯一的区别就是calloc函数会对动态开辟的内存空间进行初始化，而malloc函数不会初始化

同样使用calloc函数动态开辟一样大小的内存空间

总结：

如果希望动态开辟的内存空间初始化为0，使用calloc函数

如果没要求动态开辟的内存空间需要初始化，可以使用malloc函数

👁️👁️realloc

realloc函数是C语言提供用来调整我们动态申请的内存空间大小

我们在使用malloc，calloc函数进行动态开辟内存空间时，有时候会发现申请的内存空间过大或过小的问题，这是为了避免出现跟定长数组一样问题，C语言就提供了realloc函数让根据需要调整动态开辟的内存空间大小

参数 memblock 指向我们申请的动态内存空间
参数 size 为调整后的空间总大小
调整成功后会返回一个指针，指向调整后的内存空间
调整失败会返回一个NULL(空指针)，所以需要在使用前判断传回的是否为空指针

realloc函数动态调整内存空间会有两种情况

1.原有空间之后有足够大的空间

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

使用：

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

int main()
{
	//申请空间
	int* ptr = (int*)malloc(10 * sizeof(int));
	if (ptr == NULL)
	{
		perror("malloc");
		exit(1);
	}
	//使用...

	//再扩容10个字节
	int* tmp = (int*)realloc(ptr, 20);//因为有可能申请的空间过大，扩容失败，就会返回空指针
	if (tmp == NULL)//所以要再使用前判断是否返回的是有效地址，避免对空指针解引用
	{
		perror("realloc");
		exit(1);
	}
	//扩容成功
	ptr = tmp;//先用一个临时指针接收，避免返回空指针把由于的地址覆盖掉，丢失原有的空间地址，无法释放原有的内存空间
	//使用...

	//释放
	free(ptr);
	free(tmp);
	ptr = NULL;
	tmp = NULL;
	return 0;
}

🦴🦴常见的动态内存的错误

👁️👁️对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);
}

切记：动态开辟的空间一定要释放，并且正确释放

🦴🦴经典笔试题

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的值NULL赋值给局部变量p，实际上再并没有把开辟的空间地址给str，str还是NULL，后面

strcpy()函数里对空指针进行解引用

2.没有对开辟动态内存空间进行释放

在GetMemory()函数里面动态开辟了内存空间，但是没有对空间进行释放

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

1.返回一个局部变量的地址，造成野指针

GetMemory()函数里面开辟了一开空间来存储"hello world"，并在最后返回了该空间的起始地址，但是出了这个函数这块空间的使用

权限就归操作系统了，此时str得到这个地址，就成了野指针

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

1. 没有对动态开辟的空间free进行释放

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

1.没有将指针置为空，对已经释放掉的空间再次使用

test()函数动态开辟了一块内存空间，并把hello拷贝到开辟的内存空间里面，之后将其释放，使用权限归还给操作系统，但是没有将

指针str置为空，str还记得开辟的空间地址，后面又对str指向的空间进行使用

🦴🦴柔性数组

👁️👁️柔性数组的特点

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

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

👁️👁️柔性数组的使用

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

typedef struct st_type
{
    int i;
    int a[0];//柔性数组成员
}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;
}

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

📍今天的动态内存开辟就介绍到这，如有错误，望大佬们纠正👀👀👀

📍最后，制作不易，如果喜欢的话，可以一键三连哦，支持一下作者💕💕💕