【C语言学习之路】动态内存管理之动态内存函数

文章目录

【C语言学习之路】动态内存管理之动态内存函数
- 动态内存函数

本篇前言

我们之前学过的开辟空间的方式，开辟出来空间大小是固定的，往往在实际使用中，我们需要的空间大小在程序运行的时候才能知道，这个时候就需要使用到动态内存开辟了。

动态内存开辟是在内存的堆区开辟的。

动态内存函数

1）`malloc` 和 `free` 函数

malloc 函数：

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

void* malloc (size_t size);

size 是要开辟的内存块的大小，以字节为单位

开辟成功，返回指向开辟成功的内存空间的指针，类型为 void*，malloc 函数并不知道开辟空间的类型，在使用的时由使用者自己来决定。
开辟失败，返回空指针 NULL

free 函数：

释放动态开辟的内存（堆区）空间。

void free (void* ptr);

注意：free 不能用来释放栈区开辟的内存，栈区由编译器自动分配和释放，下面使用是错误的

int arr[10] = {0};
free(arr);  //错误，不能这么使用

malloc 和 free 的声明都在 stdlib.h 头文件中。

使用方法实例：

#include<stdio.h>
#include<stdlib.h>  /* realloc, free, NULL */
int main()
{
	//开辟10个整型空间
	int arr[10] = { 0 };  //栈区
	//动态内存开辟
	int* p = (int*)malloc(10 * sizeof(int));  //堆区
    if (p == NULL)  //对malloc函数返回值做检测
	{
		perror("malloc");  //malloc：xxxxxxxxx
		return 0;
	}
	//使用开辟的空间
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*(p + i) = i;
		//等价于：p[i] = i;
	}
	//释放开辟的空间
	free(p);  //释放开辟的空间，将其还给操作系统，但指针 p 仍然是指向开辟的空间的
	p = NULL; //手动把 p 置成NULL

	return 0;
}

注：1、在使用 malloc 函数时，一定要对其返回值做检查。2、使用完开辟的空间后，一定要记得释放空间。

如果开辟失败：perror 函数打印错误信息

2）`calloc` 函数

为 num 个大小为 size 的元素开辟一块空间，并且把空间的每个字节初始化为 0

void* calloc (size_t num, size_t size);

开辟成功，返回指向开辟成功的内存空间的指针，类型为 void*，我们可将其转换为所需类型的指针，以便解引用
开辟失败，返回空指针 NULL

与函数 malloc 的区别在于 calloc 会在返回地址之前把申请的空间的每个字节初始化为 0，而 malloc 不会初始化数据

实例说明：

#include<stdio.h>
#include<stdlib.h>  /* calloc, free, NULL */
int main()
{
	//动态开辟空间
	int* p = (int*)calloc(10, sizeof(int));
	if (p == NULL)
	{
		return 0;
	}
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d ", *(p + i));
	}
	//释放开辟的空间
	free(p);
	p = NULL;
	return 0;
}

运行结果：

3）`realloc` 函数

realloc 函数的出现让动态管理更加灵活，有时我们会发现过去申请的空间太小了，有时候我们又会觉得申请的空间过大了，那为了合理的使用内存，我们会对内存的大小做灵活的调整。而 realloc 函数就可以做到对动态开辟内存大小的调整（扩展 / 缩小）。

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

ptr 是指向以前用 malloc、calloc 或 realloc 开辟的内存块的指针，即需要调整空间的地址

size 是调整之后的新大小，以字节为单位

调整成功，返回指向调整之后的内存块的指针，可能是原始空间，也可能是新位置，类型为 void*，我们可将其转换为所需类型的指针，以便解引用
调整失败，返回空指针 NULL

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

情况1：原有空间之后有足够大的连续空间
情况2：原有空间之后没有足够大的连续空间

我们在使用 realloc 函数时一定要考虑到这两种情况

实例说明：

#include<stdio.h>
#include<stdlib.h>  /* malloc, realloc, free, NULL */
int main()
{
	//动态开辟空间
	int* p = (int*)malloc(10*sizeof(int));
	if (p == NULL)
	{
		perror("malloc");
		return 0;
	}
	//初始化
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*(p + i) = 5;
	}
	//realloc调整空间
    //p = (int*)realloc(p, 20 * sizeof(int));//可以这样写吗？
	int* ptr = (int*)realloc(p, 20*sizeof(int));
	if (ptr != NULL)  //检查空间是否调整成功
	{
		p = ptr;
	}
	//释放空间
	free(p);
	p = NULL;
	return 0;
}

注：不要用指向原始空间的指针 p 来接收，因为 realloc 有可能找不到合适的空间来调整大小，这时会返回 NULL，我们一般用一个临时指针 ptr 来接收，然后检查空间是否调整成功，如果调整成功，再将 p = ptr

运行结果：

情况1：原有空间之后有足够大的连续空间，返回原位置

情况2：原有空间后没有足够大的连续空间，返回新位置

补充：

#include<stdlib.h>  /* realloc, free, NULL */
int main()
{
	//这里功能类似于 malloc，就是直接在堆区开辟了40个字节的空间
	int* p = (int*)realloc(NULL, 40);
	if (p == NULL)
	{
		perror("realloc");
		return 0;
	}
	free(p);
	p = NULL;
	return 0;
}