【C语言】动态内存管理之4个内存函数`malloc`，`free`，`calloc`和`realloc`深度了解

学习起来吧

发布于 2024-02-29 21:47:24

910

发布于 2024-02-29 21:47:24

文章被收录于专栏：学习C/++学习C/++

?前言

本小节，我们学习动态内存管理：为什么要有动态内存分配？4个动态内存开辟函数：malloc，free，calloc和realloc，这些C标准库中的内存管理函数都声明在在 stdlib.h 头?件中。干货满满！学习起来吧?！

? 为什么要有动态内存分配？

程序运行时不确定需要多少内存空间。在编译期无法确定程序运行期间需要分配多大的内存块。这就需要在运行时动态申请和释放内存。我们已经学习内存开辟方式有：

# define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
int main()
{
	int n = 0;//在栈空间给变量开辟4个字节
	char ch = 'a';//在栈空间给变量开辟1个字节空间

	//数组 
	int arr[10] = {0};//在栈空间开辟10个字节的连续空间


	return 0;
}

但是这两种开辟的空间的方式具有局限性：

空间开辟??是固定的。
数组在申明的时候，必须指定数组的?度，数组空间?旦确定了??不能调整，如数组里的arr[10]的10不能随时更改。

这是内存大致分类图：

但是对于空间的需求，不仅仅是上述的情况。有时候我们需要的空间大小在程序运的时候才能知道，那数组的编译时开辟空间的方式就不能满足了。接下来，我们学习怎么一步一步分配空间吧！

?malloc

malloc函数是动态内存分配的基础函数（从堆内存中动态分配指定大小的内存块，并返回指向内存块的指针）。函数原型：

void *malloc(size_t size);
size_t size - 要分配的内存块大小，单位是字节。

分析函数原型例子：

int main()
{
	//int arr[10]//
	p = malloc(40);
	return 0;
}

为什么要用void * 接收类型？malloc分配40个字节空间，p存放的是分配空间的首地址，malloc只知道申请多大的空间，但是不知道会放什么类型数据，所以malloc函数就只能返回void*，当使用void*时，也就是void* p = malloc(40)，但是void*指针是不能++--的解引用操作，可是我们在分配空间时，作为程序员，你想用什么类型，就分配什么类型就可以了。比如：

int main()
{
	int* p = (int*)malloc(40);
	return 0;
}

图解：

返回值：

如果分配成功，malloc返回指向内存块的void指针。如果失败(如没有足够的可用内存)，返回NULL。

使用malloc分配的内存需要使用free函数释放，否则会造成内存泄漏。

重点：

malloc分配的内存不会被初始化，内容是未定义的。

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

一般使用步骤：

#mermaid-svg-hF39SyuWvpw7OKaD {font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;fill:#333;}#mermaid-svg-hF39SyuWvpw7OKaD .error-icon{fill:#552222;}#mermaid-svg-hF39SyuWvpw7OKaD .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-hF39SyuWvpw7OKaD .edge-thickness-normal{stroke-width:2px;}#mermaid-svg-hF39SyuWvpw7OKaD .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-hF39SyuWvpw7OKaD .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-hF39SyuWvpw7OKaD .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-hF39SyuWvpw7OKaD .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-hF39SyuWvpw7OKaD .marker{fill:#333333;stroke:#333333;}#mermaid-svg-hF39SyuWvpw7OKaD .marker.cross{stroke:#333333;}#mermaid-svg-hF39SyuWvpw7OKaD svg{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-hF39SyuWvpw7OKaD .label{font-family:"trebuchet ms",verdana,arial,sans-serif;color:#333;}#mermaid-svg-hF39SyuWvpw7OKaD .cluster-label text{fill:#333;}#mermaid-svg-hF39SyuWvpw7OKaD .cluster-label span{color:#333;}#mermaid-svg-hF39SyuWvpw7OKaD .label text,#mermaid-svg-hF39SyuWvpw7OKaD span{fill:#333;color:#333;}#mermaid-svg-hF39SyuWvpw7OKaD .node rect,#mermaid-svg-hF39SyuWvpw7OKaD .node circle,#mermaid-svg-hF39SyuWvpw7OKaD .node ellipse,#mermaid-svg-hF39SyuWvpw7OKaD .node polygon,#mermaid-svg-hF39SyuWvpw7OKaD .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-hF39SyuWvpw7OKaD .node .label{text-align:center;}#mermaid-svg-hF39SyuWvpw7OKaD .node.clickable{cursor:pointer;}#mermaid-svg-hF39SyuWvpw7OKaD .arrowheadPath{fill:#333333;}#mermaid-svg-hF39SyuWvpw7OKaD .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-hF39SyuWvpw7OKaD .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-hF39SyuWvpw7OKaD .edgeLabel{background-color:#e8e8e8;text-align:center;}#mermaid-svg-hF39SyuWvpw7OKaD .edgeLabel rect{opacity:0.5;background-color:#e8e8e8;fill:#e8e8e8;}#mermaid-svg-hF39SyuWvpw7OKaD .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-hF39SyuWvpw7OKaD .cluster text{fill:#333;}#mermaid-svg-hF39SyuWvpw7OKaD .cluster span{color:#333;}#mermaid-svg-hF39SyuWvpw7OKaD div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-hF39SyuWvpw7OKaD :root{--mermaid-font-family:"trebuchet ms",verdana,arial,sans-serif;}

1. 调用malloc分配指定大小的内存

2. 检查返回值是否为NULL

3. 使用分配到的内存

4. 调用free释放内存

例子：

#include <stdlib.h>

int main()
{
	//int arr[10];//
	//1. 调用malloc分配指定大小的内存
	int* p = (int*)malloc(10*sizeof(int));
	if (p == NULL)//2. 检查返回值是否为NULL
	{
		perror("malloc");//打印错误信息
		return 1;
	}
	//
	int i = 0;
	//使用 - 给数组赋值
	for (i = 0; i < 10; i++)
	{
		*(p + i) = i;
	}
	//打印
	for (i = 0; i < 10; i++)
	{
		printf("%d ", *(p + i));
	}

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

	return 0;
}

输出：

?free

free函数用于释放之前通过malloc、calloc或realloc分配的内存块。 free原型：

void free(void *ptr);
void *ptr - 要释放的内存块的起始地址。
这个地址必须是之前通过malloc、calloc或realloc成功分配的地址。

free函数?来释放动态开辟的内存。

释放ptr指向的内存块，使得操作系统可以重新利用该内存。
如果ptr为NULL或非动态内存地址，free函数不会产生错误，但也不会有任何效果。
free没有能力将ptr置为空指针，因此需要我们手动设置NULL。

?小知识：为什么free没有能力将ptr置为空指针？ C语言采用传值调用，形参是实参的一份临时拷贝，函数内只能操作形参，无法直接修改实参。free的形参是ptr,它无法直接修改调用函数内的ptr变量。free的功能只是释放ptr指向的内存块，它不负责跟踪或者修改调用者的内存使用情况。将ptr置NULL需要由调用者自己负责。如果free修改ptr,可能会造成调用者难以跟踪内存，增加使用错误的风险。例如内存泄漏无法及时发现。所以free后不使用了，要记得置为NULL

例子：

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

int main()
{
    int* ptr = (int*)malloc(sizeof(int) * 10);//使用malloc分配的内存块

    if (ptr == NULL) 
    {
        perror("malloc");
        return 1;
    }

    // 使用ptr指向的内存
    for (int i = 0; i < 10; i++) 
    {
        ptr[i] = i;
        printf("ptr[%d] = %d\n", i, ptr[i]);
    }

    printf("Finished using the memory, free it now:\n");

    free(ptr);
    ptr = NULL;
    printf("Memory freed!\n");

    // 释放后ptr指针不再有效
    //ptr[0] = 100; //会出错

    return 0;
}

输出：

?calloc

calloc 函数也?来动态内存分配， calloc会给申请的每个字节初始化为0,而malloc不会初始化内存。

calloc函数原型：

void *calloc(size_t num, size_t size);
- num:要申请的内存块的个数
- size:每个内存块的大小，以字节为单位

例如：

int *p = (int *)calloc(10, sizeof(int));
这段代码会给10个int类型(每个int占4字节)的内存块数组申请空间，
每个int内存将被初始化为0。

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

例子：

#include <stdio.h>
#include <stdlib.h>
int main()
{
	int* p = (int*)calloc(10, sizeof(int));
	if (NULL != p)
	{
		int i = 0;
		for (i = 0; i < 10; i++)
		{
			printf("%d ", *(p + i));
		}
	}
	free(p);
	p = NULL;
	return 0;
}

输出：

? realloc

realloc函数用于重新分配内存块的大小。

realloc函数原型：

void *realloc(void *ptr, size_t size);
 - ptr:要重新分配内存的指针，它必须指向以前通过malloc/calloc/realloc分配的内存块。
 - size:要重新分配的内存块大小，以字节为单位。

返回值为调整之后的内存起始位置。

使用起来看看：

 int main()
{
	//使用calloc动态申请10个int类型的内存
	int* p = (int*)calloc(10, sizeof(int));

	if (p == NULL)
	{
		perror("malloc");
		return 1;
	}

	//打印原始10个内存元素，由于calloc初始化都为0,所以打印全为0
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d ", *(p + i));
	}

	//空间不够，想要扩大为20个int类型
	int* ptr = (int*)realloc(p, 20 * sizeof(int));

	//空间不够，想要扩大为40个int类型
	//int* ptr = (int*)realloc(p, 40 * sizeof(int));

	if (ptr != NULL)
	{
		//realloc成功，ptr指向新的内存地址，更新p指针
		p = ptr;
	}
	else
	{
		perror("realloc");
		return 1;
	}

	//使用了扩充后的内存空间

	//释放动态申请的内存
	free(p);
	p = NULL;

	return 0;
}

输出：

使用是用了，但是他是怎么拓展空间的呢？有没有什么要注意的呢？ realloc函数调整原内存空间??的基础上，还会将原来内存中的数据移动到新的空间。

realloc在调整内存空间的是存在两种情况：

情况1：原有空间之后没有?够多的空间时，扩展的?法是：在堆空间上另找?个合适??的连续空间来使?，并且把数据拷贝过去，这样函数返回的是?个新的内存地址。

? 情况2：要扩展内存就直接原有内存之后直接追加空间，原来空间的数据不发?变化，返回的是旧的起始地址。

当然realloc也可以相当于malloc。如果参数ptr为NULL,那么realloc就等同于malloc,它会分配指定大小的内存块

 // ptr为NULL,相当于malloc
	int* p = (int*)realloc(NULL, sizeof(int) * 10);

	if (p == NULL)
	{
		perror("malloc");
		return 1;
	}

?总结

这次阿森和你一起学习了声明在stdlib.h头文件中的4个内存管理函数malloc(), free(), calloc() 和 realloc() ，

malloc() - 分配内存块 - void* malloc (size_t size); free() - 释放内存块 - void free (void* ptr); calloc() - 分配并清零初始化内存块 - void* calloc (size_t num, size_t size); realloc() - 重新分配内存块大小 - void* realloc (void* ptr, size_t size);

阿森将下一节和你一起学习常见动态内存错误.，动态内存经典笔试题分析，柔性数组，总结C/C++中程序内存区域划分? 。

感谢你的收看，如果文章有错误，可以指出，我不胜感激，让我们一起学习交流，如果文章可以给你一个小小帮助，可以给博主点一个小小的赞?

本文参与?腾讯云自媒体分享计划，分享自作者个人站点/博客。

原始发表：2024-02-29，如有侵权请联系 cloudcommunity@tencent.com 删除

free