C语言动态内存管理（malloc，calloc，free，realloc）

原创已于 2023-02-13 12:54:44 修改 · 900 阅读

5 ·

CC 4.0 BY-SA版权

文章标签：

#c语言 #c++ #算法

于 2022-09-24 20:35:33 首次发布

C 专栏收录该内容

22 篇文章

订阅专栏

本文介绍了动态内存管理的函数，包括malloc、free、calloc和realloc的使用，并列举了动态内存管理中常见的错误，如空指针解引用、越界访问、非法释放等。此外，还通过四道面试题目展示了动态内存管理的陷阱及解决方案，强调了防止内存泄漏和正确释放内存的重要性。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

前言

为什么会引出动态内存开辟这个功能呢？

那是因为向我们之前学习的数组，一旦创建之后所占用的空间就不会改变，可能会造成空间的浪费或者开辟空间的不足。

一，malloc

void* malloc(size_t num)
1，函数的返回类型为空指针类型，如果为开辟成功那么返回NULL
2，函数的参数为开辟空间的大小（单位：字节）
3，函数开辟的空间十载内存中的堆区开辟的，会在整个程序结束后自动销毁
4，演示

#include<stdio.h>
#include<stdlib.h>
int main()
{
	int* p = (int*)malloc(sizeof(int) * 5);
	if (p == NULL)
	{
		perror("malloc");
	}
	else
	{
		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;
}

在这里插入图片描述
注意：开辟不成功返回NULL

#include<stdio.h>
#include<stdlib.h>
#include<limits.h>
int main()
{
	int* p = (int*)malloc(INT_MAX*sizeof(int));
	if (p == NULL)
	{
		perror("malloc");
	}
	else
	{
		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;
}

在这里插入图片描述

二，free

void free(void* ptr)
1，函数的返回值为空，函数的参数为空指针
2，作用是将ptr指向的动态开辟的空间释放
3，可以free（NULL）
4，我们在动态开辟内存空间后，并且使用完后，要及时free释放空间，避免造成内存泄漏。
5，free掉空间后，最好将原指针指向NULL，避免造成非法访问
在这里插入图片描述

三，calloc

void* calloc(size_t num,size_t n)
1，函数的返回值为空指针类型
2，第一个参数表示开辟元素的个数，第二个参数表示每个元素的大小（单位：字节）
3，calloc与malloc大体相同，区别为calloc申请的空间会被初始化为0.
在这里插入图片描述

四，realloc

void* realloc (void* ptr, size_t size)
1，函数的返回值为空指针类型
2，第一个参数为空指针类型是一块动态开辟空间的地址，第二个参数是重新调整后动态开辟空间的大小
3，realloc（NULL，40）==malloc（NULL，40）
4，这个函数可以对之前开辟的空间重新调整可大可小
5，在用realloc函数扩容的时候，若原空间后面的空间充足，那么新开辟的空间就是与原空间挨着的后面的空间
在这里插入图片描述
6，在用realloc函数扩容的时候，若原空间后面的空间不充足，那么会找到一块新的空间大小为扩容后的大小，并且会将原空间的内容拷贝到新空间中，还会释放掉原空间。

可以看到当扩容的空间较小时，会直接在原空间的基础上开辟新的空间。

在这里插入图片描述

可以看到当扩容的空间较大时，系统会重新找到一块空间。
7，在使用realloc缩容的时候，可能会原地缩容也可能会异地缩容。

五，动态内存管理的常见问题

1，对空指针进行解引用操作

void test2()
{
	int* p = (int*)malloc(sizeof(int) * INT_MAX);
	*p = 20;
	free(p);
}

这里如果p为空指针的话，那么就会对空指针解引用。

如何改进呢？

void test2()
{
	int* p = (int*)malloc(sizeof(int) * INT_MAX);
	if (p == NULL)
	{
		perror("malloc");
	}
	else
	{
		*p = 20;
	}
	free(p);
	p = NULL;
}

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

void test3()
{
	int* p = (int*)malloc(sizeof(int) * 5);
	if (p != NULL)
	{
		int i = 0;
		for (i = 0; i < 10; i++)
		{
			*(p + i) = i;
		}
	}
	free(p);
	p = NULL;
}

这里看到我们用malloc开辟了20个字节的内容，而我们在赋值的时候却访问了40个字节的内容，这就造成了，对动态开辟内存空间的越界访问。

3，对非动态开辟的内存空间free

void test4()
{
	int a = 10;
	free(&a);
}

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

void test5()
{
	int* p = (int*)malloc(sizeof(int) * 5);
	if (p != NULL)
	{
		int i = 0;
		for (i = 0; i < 5; i++)
		{
			*p = i;
			p++;
		}
	}
	free(p);
	p = NULL;
}

我们在赋值的时候已经将p指向的空间移动，这样之后就不能再用free（p）来释放动态开辟的空间

5，对一块动态开辟的空间多次释放

void test6()
{
	int* p = (int*)malloc(sizeof(int) * 5);
	free(p);
	//...
	//...
	//...
	//...
	free(p);
}

6，动态开辟的内存空间忘记释放（内存泄漏）

这就是内存开辟之后，使用完忘记释放空间。

void test5()
{
	int* p = (int*)malloc(sizeof(int) * 5);
	if (p != NULL)
	{
		int i = 0;
		for (i = 0; i < 5; i++)
		{
			*(p + i) = i;
		}
	}
	
}

注：以上就是动态内存开辟过程中容易出错的六个地方，在你写代码的时候要注意哟。

六，四道经典面试题目

每道题目哪里出了问题？

第一道

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

1，对p开辟的空间，并不会带回函数test中，所以str一直指向的都是NULL，在调用strcpy时，会造成对空指针解引用。
2，对动态开辟的空间没有free

纠正

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

第二道

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

这是一种常见的错误就是，返回栈空间地址，函数返回了p指针p但是指针p指向的内容已被销毁。

第三道

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，主要问题是没有释放动态开辟的内存空间造成内存泄漏。
2，还有一个小问题就是在使用str时没有提前判断str是否为空指针

纠正

void GetMemory2(char** p, int num)
{
	*p = (char*)malloc(num);
}
void Test2(void)
{
	char* str = NULL;
	GetMemory(&str, 100);
	if (str != NULL)
	{
		strcpy(str, "hello");
		printf(str);
	}
	free(str);
	str = NULL;
}

第四道

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

1，这道题的问题所在是，释放掉str所指向的空间后，没有将str指向空指针。这造成了调用strcpy函数时形成了非法访问。

纠正

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

以上四道题目都出自《高质量的C/C++编程》这本书中。

链接：https://pan.baidu.com/s/19mSw3miWFz7GYaMfaZ3uIw
提取码：kbtz