写在前面

本文介绍了C语言中四个常用的内存分配和释放函数，它们是：malloc、calloc、realloc 、free。文章中讨论了这些函数的使用方法，示例代码，常见的动态内存错误以及如何防止内存泄漏。

1. malloc 和 free函数

malloc和free是C语言中用于动态内存分配和释放的函数，它俩基本上都是配套使用的。malloc和free的声明在 stdlib.h 头文件中。

1.1 malloc函数介绍

函数原型：

void* malloc (size_t size);

• 函数参数：size表示要申请的内存大小，单位是字节。如果参数 size 为0，malloc的行为是标准是未定义的，取决于编译器。
• 函数返回值：返回一个void*类型的指针，这是因为malloc函数并不知道开辟空间的类型，所以在使用的时候由使用者自己来决定。如果开辟成功，则返回动态开辟空间的起始地址；如果开辟失败，返回空指针（NULL）,因此对malloc的返回值一定要做检查。

以下代码，演示了如何使用malloc函数来动态申请内存并在其中存储整数数据：

#include <stdio.h>
#include <stdlib.h>int main() 
{int* arr;int size = 5;// 使用malloc分配整数数组的内存arr = (int*)malloc(size * sizeof(int));//对malloc的返回值进行检查if (arr == NULL) {perror("malloc");return 1;}// 在动态数组中存储数据for (int i = 0; i < size; i++) {arr[i] = i;}// 使用动态数组中的数据for (int i = 0; i < size; i++){printf("%d ", arr[i]);}// 释放动态分配的内存free(arr);arr = NULL;return 0;
}

需要注意的是：
使用malloc函数动态申请的空间在不需要使用的时候要用free函数释放，以避免内存泄漏。释放内存后，应将指针设置为NULL，以避免出现野指针的问题。

1.2 free函数介绍

函数原型：

void free (void* ptr);

• 函数参数：ptr是要释放的内存空间起始地址。

free函数主要是用来回收内存的，用于释放先前通过动态内存函数（例如malloc、calloc、realloc等）申请的空间。

需要注意的是：

• 如果参数 ptr 指向的空间不是动态开辟的，那free函数的行为是未定义的。
• 如果参数 ptr 是NULL指针，则函数什么事都不做。

以下代码，演示了如何使用free函数来释放动态申请的内存：

#include <stdio.h>
#include <stdlib.h>int main()
{int* arr;int size = 5;// 使用malloc分配整数数组的内存arr = (int*)malloc(size * sizeof(int));//对malloc的返回值进行检查if (arr == NULL){perror("malloc");return 1;}// 使用内存// ....// 释放动态分配的内存free(arr);arr = NULL;return 0;
}

2. calloc函数

函数原型：

void* calloc (size_t num, size_t size);

• num：表示要分配的元素的数量。
• size：表示每个元素的大小（以字节为单位）。
• 返回值：如果开辟成功，则返回动态开辟空间的起始地址；如果开辟失败，返回空指针（NULL）,因此对calloc的返回值也要做检查。

表面上看calloc和malloc函数的功能非常相似，但它与malloc也是有区别的。区别只在于 calloc 会在返回地址之前把申请的空间的每个字节初始化为全0。

以下是上面图片中的代码：

#include <stdio.h>
#include <stdlib.h>int main()
{int* ptr;// 使用calloc申请空间ptr = (int*)calloc(5, sizeof(int));//对calloc的返回值进行检查if (ptr == NULL){perror("malloc");return 1;}// 使用内存// ....// 释放动态分配的内存free(ptr);ptr = NULL;return 0;
}

需要注意的是：

• 和malloc类似，使用calloc函数动态申请的空间在不需要使用的时候也需要用free函数释放，以避免内存泄漏。释放内存后，也应将指针设置为NULL，以避免出现野指针的问题。
• 如果我们对申请的内存空间的内容要求初始化，可以使用calloc函数来完成任务。

3. realloc函数

函数原型：

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

• ptr：是先前分配的内存区域的起始地址。
• size：是重新分配后的内存块的新大小，单位是字节。
• 返回值：如果调整成功，则返回一个调整好的空间的起始地址；如果调整失败，返回空指针（NULL）,因此对realloc的返回值一定要做检查。

realloc 函数是用来调整动态开辟的内存大小的。realloc在调整内存空间是存在两种情况：
情况1：原有空间之后有足够大的空间。

情况2：原有空间之后没有足够大的空间。
当是情况2的时候，原有空间之后没有足够多的空间时，扩展的方法是：在堆空间上另找一个合适大小的连续空间来使用。这样函数返回的是一个新的内存地址。

以下代码，首先使用malloc申请一块初始大小的内存，然后使用realloc调整初始内存。

#include <stdio.h>
#include <stdlib.h>int main() 
{int* arr;size_t sz = 5;size_t newSz = 10;// 分配内存arr = (int*)malloc(sz * sizeof(int));if (arr == NULL) {perror("malloc");return 1;}// 使用内存// 重新分配内存int* _arr = (int*)realloc(arr, newSz * sizeof(int));if (_arr == NULL) {perror("malloc");free(arr);return 1;} else{arr = _arr;}// 使用重新分配后的内存// 释放内存free(arr);arr = NULL;return 0;
}

4. 常见的动态内存错误

4.1 对NULL指针的解引用操作

对NULL指针进行解引用操作是一种非常严重的错误，因为NULL指针表示一个无效的内存地址，尝试访问它的内容将导致未定义的行为，通常会导致程序崩溃。
如下面代码，如果malloc开辟空间失败就会返回空指针，造成对NULL指针进行解引用。

#include <stdio.h>
#include <stdlib.h>void test()
{int *p = (int *)malloc(INT_MAX/4);*p = 20;//如果p的值是NULL，就会有问题free(p);
}int main()
{test();return 0;
}

代码改正：
检查指针是否为NULL：在进行指针解引用操作之前，应该先检查指针是否为NULL。

#include <stdio.h>
#include <stdlib.h>void test()
{int *p = (int *)malloc(INT_MAX/4);//解引用之间，检查指针是否为NULLif (p == NULL){perror("malloc");return;}*p = 20;//如果p的值是NULL，就会有问题free(p);p = NULL;
}int main()
{test();return 0;
}

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

对动态开辟空间的越界访问是指在使用malloc、calloc、realloc等动态内存分配函数分配的内存空间中，访问超出申请空间的内存位置。这是一种严重的编程错误，通常会导致不可预测的行为和程序崩溃。

如下面代码，当 i 是10的时候越界访问。

#include <stdio.h>
#include <stdlib.h>void test()
{int i = 0;int *p = (int *)malloc(10*sizeof(int));if(NULL == p){perror("malloc");return;}for(i=0; i<=10; i++){*(p+i) = i;//当i是10的时候越界访问}free(p);p = NULL;
}int main()
{test();return 0;
}

因此，在使用指针进行操作时，一定要确保我们了解分配内存的大小，以避免越界访问。

4.3 对非动态开辟内存使用free释放

使用 free 函数释放非动态分配的内存是一种非常严重的错误。free 函数应该仅用于释放通过 malloc、calloc、realloc 等动态内存分配函数申请的空间。如果尝试使用 free 来释放不是动态分配的内存，将导致不可预测的行为，通常会导致程序崩溃。

如下代码，试图使用 free 释放栈上局部变量，这将导致程序崩溃。

void test()
{int a = 10;int *p = &a;free(p);//ok?
}
int main()
{test();return 0;
}

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

free 函数通常用于释放整个动态申请的空间，而不是它的一部分。一旦我们使用 malloc、calloc 或 realloc 分配了内存，就只能使用 free 来释放整个块。如果使用free释放一块动态开辟内存的一部分，通常会导致程序崩溃。

4.5 对同一块动态内存多次释放

多次释放同一块动态内存是一种非常严重的错误，通常会导致不可预测的行为和程序崩溃。这是因为一旦申请的空间被释放，它就不再属于当前的程序，再次释放它将导致内存错误。
如何避免同一空间被重复释放？
我们可以在每次释放后将指针设为NULL：一旦我们使用 free 函数释放了动态分配的内存，将指针设为 NULL，后续在通过该指针进行内存释放的时候就不会出问题了，这是因为当free函数的参数 是NULL指针时，函数什么事都不做。

	int* ptr = (int*)malloc(sizeof(int));// ...free(ptr);ptr = NULL; // 将指针设为 NULL，避免再次释放

4.6 动态开辟内存忘记释放（内存泄漏）

内存泄漏是指在程序运行过程中动态申请的的空间没有被释放，导致程序持续占用系统内存而不释放，最终可能导致系统内存资源被耗尽。由于忘记释放不再使用的动态开辟的空间会造成内存泄漏，因此，动态开辟的空间一定要释放，并且正确释放 。

有句说的好，一个人想写出来有bug的代码，是拦不住的。因此，我们在编程的时候，如果能避免这些动态内存错误，那么我们写出的代码将是高质量、稳定和可维护的代码！！！

至此，本片文章就结束了，若本篇内容对您有所帮助，请三连点赞，关注，收藏支持下。
创作不易，白嫖不好，各位的支持和认可，就是我创作的最大动力，我们下篇文章见！
如果本篇博客有任何错误，请批评指教，不胜感激 ！！！