由浅到深认识C语言（9）：动态内存分配

该文章Github地址：https://github.com/AntonyCheng/c-notes【有条件的情况下推荐直接访问GitHub以获取最新的代码更新】

在此介绍一下作者开源的SpringBoot项目初始化模板（Github仓库地址：https://github.com/AntonyCheng/spring-boot-init-template【有条件的情况下推荐直接访问GitHub以获取最新的代码更新】& CSDN文章地址：https://blog.csdn.net/AntonyCheng/article/details/136555245），该模板集成了最常见的开发组件，同时基于修改配置文件实现组件的装载，除了这些，模板中还有非常丰富的整合示例，同时单体架构也非常适合SpringBoot框架入门，如果觉得有意义或者有帮助，欢迎Star & Issues & PR！

上一章：由浅到深认识C语言（8）：指针的概念与应用

9.动态内存分配

在数组中谈到过，数组的长度是预先定义好的，在整个程序中固定不变，但是往往实际开发中，内存空间取决于实际输入的数据，这是无法预先确定的，所以在 C 语言中提供了一些内存管理的函数，这些函数可以按需进行内存的动态分配，也可以把不再使用的空间进行回收利用；

静态分配定义：

在程序运行过程中，事先规定内存分配的大小，需要提前知道所需空间的大小，分配在栈区或者全局变量区，一般就是数组；

动态分配定义：

在程序运行过程中，按照所需大小自由分配所需内存空间，分配在堆区，一般使用特定的函数进行分配；在堆区中的内存，如果处理不当会造成污染，所以有一个原则：谁申请谁释放，谁污染谁处理；

9.1.malloc函数（申请内存）

头文件： #include<stdlib.h>

头文件说明：从内存的动态分配开始一定要注意头文件的包含；

函数原型： void* malloc(unsigned int num_bytes);

函数原型说明：参数是无符号整形字节数，返回值是一个万能指针，即这一片所申请内存的起始地址，所以使用时一定要注意类型的强制转换；

调用形式： (类型说明符*)malloc (size);

调用形式说明：第一个括号表示类型的强制转换，第二个括号表示申请的内存大小；

功能说明： 在内存的堆区中分配一块长度为 size 字节的连续区域，用来存放类型说明符指定类型的数据，注意！分配的内存空间内容不确定时的，一般使用 memset 初始化，如果返回分配空间的起始地址，那就代表分配成功，如果返回 NULL，那就代表分配失败；所以调用 malloc 之后，一定要判断一下内存申请是否成功，如果多次 malloc 申请内存，每次申请的内存不一定是连续的；

memset函数：

头文件： #include<string.h>

调用形式： memset(首地址,初始化内容,初始化内存大小);

调用形式说明：一般我们讲所申请得到的不确定内容初始化为 0 ，所以初始化内容一般都会设置成零，如果设置成其他数值，那么就会初始化为其他数值；

9.2.free函数（释放函数）

头文件： #include<stdlib.h>

函数定义： void free(void* printer);

函数说明： free 函数释放 printer 指向的内存，该内存必须是 malloc 、calloc 、relloc 动态申请的内存；

free 函数释放空间的含义是回收空间使用权限至系统，以便于其他进程也可以使用这一片释放后的空间，但是是否对该空间的内容清零或者重新随机操作不能确定；

9.3.内存分配示例

示例一：

申请并且释放一个 int 数据类型的内存空间：

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

void test() {
	int* addr = NULL;
	addr = (int*)malloc(sizeof(int));
	if (addr == NULL) {//判断是否申请失败
		printf("malloc err\n");
		return;
	}
	printf("*addr=%d\n", *addr);//这是一个不确定的值
	free(addr);//释放堆区空间
}
int main(int argc, char* argv[]) {
	test();
	return;
}

打印效果如下：

这个地址中的内容是一个随机的数据，在这基础上我们将其清零：

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
void test() {
	int* addr = NULL;
	addr = (int*)malloc(sizeof(int));
	if (addr == NULL) {//判断是否申请失败
		printf("malloc err\n");
		return;
	}
	printf("*addr=%d\n", *addr);//这是一个不确定的值
	//对堆区空间进行清零：第一个参数是需要清零空间的首地址
	//				  第二个参数是重置的内容，清零则为零
	//				  第三个参数是需要清零的内存大小		
	memset(addr, 0, sizeof(int));
	printf("*addr=%d\n", *addr);
	free(addr);//释放堆区空间
}
int main(int argc, char* argv[]) {
	test();
	return;
}

打印效果如下：

此时我们可以在没有释放的情况下对该空间进行操作，比如说赋值：

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
void test() {
	int* addr = NULL;
	addr = (int*)malloc(sizeof(int));
	if (addr == NULL) {//判断是否申请失败
		printf("malloc err\n");
		return;
	}
	printf("*addr=%d\n", *addr);//这是一个不确定的值
	//对堆区空间进行清零：第一个参数是需要清零空间的首地址
	//					  第二个参数是重置的内容，清零则为零
	//					  第三个参数是需要清零的内存大小		
	memset(addr, 0, sizeof(int));
	printf("*addr=%d\n", *addr);
	//对addr的空间进行操作
	*addr = 1000;
	printf("*addr=%d\n", *addr);
	free(addr);//释放堆区空间
}
int main(int argc, char* argv[]) {
	test();
	return;
}

打印效果如下：

示例二：

申请并释放一个 int 数组的内存空间，这个内存大小由用户决定：

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
void test() {
	//从键盘获取用户想要申请的数组大小
	int n = 0;
	printf("请输入元素个数：");
	scanf_s("%d", &n);
	//根据大小从堆区申请内存空间
	int* arr = NULL;
	arr = (int*)malloc(n*sizeof(int));
	if (arr == NULL) {
		printf("err\n");
		return;
	}
	memset(arr, 0, n * sizeof(int));
	//对空间进行读写操作
	printf("请输入%d个整数：", n);
	for (int i = 0; i < n; i++) {
		scanf_s("%d", arr + i);
	}
	for (int i = 0; i < n; i++) {
		printf("%d ", *(arr + i));//或者arr[i]
	}
	//释放该空间
	free(arr);
}
int main(int argc, char* argv[]) {
	test();
	return;
}

打印效果如下：

这样就可以不用使用固定的内存大小来存放数据，这也是数组在底层存储方式的表现；

示例三：

申请并释放一个 int 数组的内存空间，这个内存大小由用户决定（用分函数和指针参数的形式完成）：

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
void get_mem(int** arr, int* n) {
	printf("请输入元素个数：");
	scanf_s("%d", n);
	*arr = (int*)malloc((*n) * sizeof(int));
	memset(*arr, 0, ((*n) * sizeof(int)));
}
void set_mem(int** arr, int* n) {
	printf("请输入%d个整数：", *n);
	for (int i = 0; i < *n; i++) {
		scanf_s("%d", (*arr) + i);
	}
}
void show_mem(int** arr, int* n) {
	for (int i = 0; i < *n; i++) {
		printf("%d ", *((*arr) + i));
	}
}
void test() {
	int* arr = NULL;
	int n = 0;
	//给arr申请合法的空间；
	get_mem(&arr, &n);
	//对空间进行操作；
	set_mem(&arr, &n);
	//展示空间
	show_mem(&arr, &n);
	//释放空间；
	free(arr);
}
int main(int argc, char* argv[]) {
	test();
	return;
}

打印效果如下：

9.4.calloc函数（申请内存）

头文件：#include<stdlib>

函数原型： void* calloc(unsigned int mem,unsigned int size);

调用形式： (类型说明符*)calloc(unsigned int mem,unsigned int size);

函数功能： 在内存的堆区申请 mem 块，每块的大小为 size 个字节的连续区域；

char* p = (char*)calloc(3,100); 
//这里申请的就是 3 块连续的 100B 内存

malloc 和 calloc 的区别：

• 函数名不一样；
• 参数个数不一样；
• malloc 申请的内存内容是随机的，不能确定；
  calloc 申请的内存内容为 0；

示例如下：

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
void test() {
	//从键盘获取用户想要申请的数组大小
	int n = 0;
	printf("请输入元素个数：");
	scanf_s("%d", &n);
	//根据大小从堆区申请内存空间
	int* arr = NULL;
	arr = (int*)calloc(n,sizeof(int));
	if (arr == NULL) {
		printf("err\n");
		return;
	}
	//对空间进行读写操作
	printf("请输入%d个整数：", n);
	for (int i = 0; i < n; i++) {
		scanf_s("%d", arr + i);
	}
	for (int i = 0; i < n; i++) {
		printf("%d ", *(arr + i));//或者arr[i]
	}
	//释放该空间
	free(arr);
}
int main(int argc, char* argv[]) {
	test();
	return;
}

打印效果如下：

9.5.realloc函数(动态增减内存)

头文件：#include<stdlib>

函数原型： void* calloc(void* s,unsigned int newsize);

调用形式： (类型说明符*)calloc(void* s,unsigned int newsize);

函数功能： 在原先s指向的内存基础上重新申请内存，新的内存的大小为 new_size 个 字节，如果原先内存后面有足够大的空间，就追加，如果后边的内存不 够用，则realloc函数会在堆区找一个newsize个字节大小的内存申请，将原先内存中的内容拷贝过来，然后释放原先的内存，最后返回新内存的地址；

参数：s：原先开辟内存的首地址；newsize：新申请的空间总大小（加上原空间大小）；

**返回值：**新申请的内存的首地址，一定要保存 realloc 的返回值；

注意：realloc 方法只能运用在 malloc 方法和 calloc 方法之后

追加空间示例如下：

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

void test() {
	int* arr = NULL;
	int n = 0;
	int n_new = 0;
	printf("请输入元素的个数：");
	scanf_s("%d", &n);
	arr = (int*)calloc(n, sizeof(int));
	if (arr == NULL) {
		printf("err");
		return;
	}
	printf("请输入%d个int数据:\n", n);
	for (int i = 0; i < n; i++) {
		scanf_s("%d", arr + i);
	}
	for (int i = 0; i < n; i++) {
		printf("%d", *(arr + i));
	}
	//再追加五个元素;
	printf("请输入新增的元素个数：");
	scanf_s("%d", &n_new);
	arr = (int*)realloc(arr, (n + n_new) * sizeof(int));
	printf("请输入新增的%d个int数据:\n", n_new);
	for (int i = n; i < (n + n_new); i++) {
		scanf_s("%d", arr + i);
	}
	for (int i = 0; i < (n + n_new); i++) {
		printf("%d ", *(arr + i));
	}
	free(arr);
}
int main(int argc, char* argv[]) {
	test();
	return;
}

打印效果如下：

减少空间示例如下：

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

void test() {
	int* arr = NULL;
	int n = 10;
	arr = (int*)malloc(n * sizeof(int));
	if (arr == NULL) {
		// perror 不仅会打印内容，还会打印出错误的原因
		perror("err");
	}
	memset(arr, 0, n * sizeof(int));
	printf("请输入%d个整数：\n",n);
	for (int i = 0; i < n; i++) {
		scanf_s("%d", arr + i);
	}
	printf("你输入的数为：\n");
	for (int i = 0; i < n; i++) {
		printf("%d ", *(arr + i));
	}
	printf("\n");

	printf("请输入你要缩减的个数：\n");
	int num = 0;
	scanf_s("%d", &num);
	printf("我们将这个数组缩减为%d个！\n",num);
	arr = (int*)realloc(arr, num * sizeof(int));
	printf("缩减成功！下面是缩减后的数组：\n");
	for (int i = 0; i < num; i++) {
		printf("%d ", *(arr + i));
	}
    free(arr);
}

int main(int argc, char* argv[]) {
	test();
	return;
}

打印效果如下：

9.6.堆区空间使用的注意事项

• 指向堆区空间的指针变量不要随意更改指向；

  int* p = (int*)calloc(1, sizeof(int));
  int num = 10;
  p = #
  

  如果这样做的话会导致申请的空间污染内存；

• 要操作已经释放的空间；

  int* p = (int*)calloc(1, sizeof(int));
  free(p);
  printf("*p2 = %d\n", *p);
  

  如果这样做的话会得到不确定的空间，相当于操作一个没有被初始化的指针；

• 不要对堆区空间重复释放；

  int* p = (int*)calloc(1, sizeof(int));
  free(p);
  free(p);
  

  如果这样做的话，第二次相当于释放了一个没有被初始化的指针；

9.7.防止多次释放

为了防止多次释放，我们可以在每一次释放的时候都加上一些限制，即判断其是否为空，为空就不会释放，不为空就会被释放，同时让指针在指向空；

示例如下：

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

void test() {
	int* p = NULL;
	p = (int*)calloc(1, sizeof(int));
	if (p != NULL) {  //限制在这里
		free(p);
		p = NULL;
	}
}

int main(int argc, char* argv[]) {
	test();
	return;
}

下一章：由浅到深认识C语言（10）：字符串处理函数