C语言内存管理：堆内存

什么是堆内存？

堆内存是一个允许开发者自由使用的内存区域，用于动态内存分配。在程序运行时，开发者可以根据实际需求，通过调用malloc、calloc、realloc等函数来申请堆内存空间，并且在不再需要这些内存时，使用free函数手动释放。

为何使用堆内存？

当开发者需要处理动态数据结构时，如链表这种数据结构，它的节点数量和每个节点的数据大小在编译时往往是不确定的，需要在程序运行时根据实际情况动态创建和销毁节点。此时，就需要使用堆内存，可以使用malloc函数为每个节点分配内存空间，使用free函数释放不再使用的节点内存，从而实现链表的动态管理。​
​

// 定义链表节点结构​
typedef struct Node {​
int data;​
struct Node* next;​
} Node;​
​
// 创建新节点​
Node* createNode(int data) {​
Node* newNode = (Node*)malloc(sizeof(Node));​
if (newNode == NULL) {​
// 内存分配失败处理​
return NULL;​
}​
newNode->data = data;​
newNode->next = NULL;​
return newNode;​
}​
​
// 释放链表内存​
void freeList(Node* head) {​
Node* current = head;​
Node* next;​
while (current != NULL) {​
next = current->next;​
free(current);​
current = next;​
}​
}​

​
另外当需要存储大量数据时，栈内存往往无法满足需求。而堆内存的大小仅受限于系统的可用内存，因此可以用来存储大规模的数据。例如，在处理图像、音频等大数据文件时，可以使用堆内存来分配足够的空间来存储这些数据，以便进行后续的处理和分析。​

堆内存管理函数

malloc 函数

malloc函数用于从堆内存中申请空间，其原型为void *malloc(size_t size)。功能是在堆内存中分配一块指定大小的连续内存空间，并返回一个指向该内存起始地址的指针。这里的参数size表示要分配的内存大小，单位是字节。​
例如，当需要分配一个能存储 10 个整数的内存空间时，可以这样使用malloc函数：​​

#include <stdio.h>​
#include <stdlib.h>​
​
int main() {​
int *ptr;​
// 分配10个整数大小的内存空间​
ptr = (int *)malloc(10 * sizeof(int));​
if (ptr == NULL) {​
printf("内存分配失败\n");​
return 1;​
}​
// 使用分配的内存​
for (int i = 0; i < 10; i++) {​
ptr[i] = i;​
}​
// 输出内存中的数据​
for (int i = 0; i < 10; i++) {​
printf("%d ", ptr[i]);​
}​
// 释放内存​
free(ptr);​
return 0;​
}​
​

在这个例子中，malloc(10 * sizeof(int))表示申请一个大小为10个整数的内存空间，由于sizeof(int)返回一个int类型变量占用的字节数，这样就能确保分配的空间足够存储10个整数。(int *)是类型转换，将malloc返回的void*类型指针转换为int*类型指针，以便后续操作。​
需要特别注意的是，当malloc函数无法分配到足够的内存时，它会返回NULL。因此，在使用malloc分配内存后，一定要检查返回值是否为NULL，以避免对空指针进行操作，从而导致程序崩溃或出现其他未定义行为。​

calloc 函数

calloc函数的原型是void *calloc(size_t numElements, size_t sizeOfElement) ，它的功能是在堆内存中分配numElements个大小为sizeOfElement的连续内存块，并将这些内存块初始化为 0 。与malloc函数相比，calloc函数有两个明显的特点：一是按块分配内存，二是自动初始化内存为 0。​
例如要创建一个包含 5 个双精度浮点数的数组，并确保数组元素初始值都为 0，可以使用calloc函数：​
​

#include <stdio.h>​
#include <stdlib.h>​
​
int main() {​
double *arr;​
// 分配5个双精度浮点数大小的内存空间，并初始化为0​
arr = (double *)calloc(5, sizeof(double));​
if (arr == NULL) {​
printf("内存分配失败\n");​
return 1;​
}​
// 输出数组中的数据​
for (int i = 0; i < 5; i++) {​
printf("%lf ", arr[i]);​
}​
// 释放内存​
free(arr);​
return 0;​
}​

​
在这个示例中，calloc(5, sizeof(double))表示分配 5 个大小为sizeof(double)的内存块，总共分配的内存大小为5 * sizeof(double)字节，并且这些内存块中的每一个字节都被初始化为 0 。​
calloc函数在需要初始化内存的场景中非常实用，比如用于统计计数的数组，使用calloc分配内存后就可以直接基于初始的 0 值开始进行计数等操作，无需额外再去初始化内存空间。但由于calloc函数在分配内存后会进行初始化操作，这会导致它的执行效率相对malloc函数略低一些，所以在对内存初始内容没有特定要求，或者后续程序会立即覆盖内存原有随机数据的场景中，更适合使用malloc函数。​

realloc 函数​

realloc函数的原型为void *realloc(void *ptr, size_t size) ，它的主要作用是调整之前通过malloc、calloc或realloc函数分配的内存空间大小。这里的ptr是指向要调整大小的内存块的指针，size是调整后的内存大小，单位为字节。​
当需要扩大或缩小已分配的内存空间时，就需要使用realloc函数。例如，假设已经分配了一个包含 10 个整数的数组，后来发现需要将其扩大到 20 个整数的大小，可以使用realloc函数来实现：​
​

#include <stdio.h>​
#include <stdlib.h>​
​
int main() {​
int *ptr;​
// 分配10个整数大小的内存空间​
ptr = (int *)malloc(10 * sizeof(int));​
if (ptr == NULL) {​
printf("内存分配失败\n");​
return 1;​
}​
// 向原内存中写入数据​
for (int i = 0; i < 10; i++) {​
ptr[i] = i;​
}​
// 扩大内存到20个整数大小​
int *newPtr = (int *)realloc(ptr, 20 * sizeof(int));​
if (newPtr == NULL) {​
printf("内存重新分配失败\n");​
return 1;​
}​
ptr = newPtr;​
// 向新扩大的内存中写入数据​
for (int i = 10; i < 20; i++) {​
ptr[i] = i;​
}​
// 输出内存中的数据​
for (int i = 0; i < 20; i++) {​
printf("%d ", ptr[i]);​
}​
// 释放内存​
free(ptr);​
return 0;​
}​

​
在这个例子中，首先使用malloc函数分配了 10 个整数大小的内存空间，然后使用realloc函数将内存空间扩大到 20 个整数大小。realloc函数会尝试在原有内存块的基础上进行扩展，如果原有内存块后面有足够的连续空间，它会直接在后面追加空间，此时返回的指针仍然是原来的指针；如果原有内存块后面没有足够的空间，realloc会在堆内存中寻找另一个合适大小的连续空间，将原内存中的数据拷贝到新空间，然后释放原内存块，返回新的内存起始地址。
另外，如果realloc函数的第一个参数ptr为NULL ，那么它的行为就和malloc函数一样，会分配一块大小为size的新内存。​

free 函数​

free函数的原型为void free(void *ptr) ，它的功能是释放由malloc、calloc或realloc函数分配的动态内存空间，从而使这些内存可以被重新分配和使用，有效避免内存泄漏的问题。​
例如，之前使用malloc函数分配了内存空间，当不再需要这些空间时，就可以使用free函数来释放：​
​

#include <stdio.h>​
#include <stdlib.h>​
​
int main() {​
int *ptr;​
// 分配内存​
ptr = (int *)malloc(10 * sizeof(int));​
if (ptr == NULL) {​
printf("内存分配失败\n");​
return 1;​
}​
// 使用内存​
// 释放内存​
free(ptr);​
// 避免悬空指针，将指针置为NULL​
ptr = NULL;​
return 0;​
}​

​
在使用free函数时，需要注意下面几点：​
1、不能释放非动态开辟的空间：free函数只能用于释放通过malloc、calloc、realloc等函数动态分配的内存空间。不能使用free去释放一个在栈上定义的数组，因为栈上的内存是由系统自动管理的，手动使用free会导致未定义行为。​
​

int main() {​
int arr[10] = {0};​
free(arr); // 错误，arr是栈上的数组，不能用free释放​
return 0;​
}​

​
2、不能释放动态开辟内存的一部分：free函数需要传入动态分配内存的起始地址，不能只释放其中的一部分。例如，如果使用malloc分配了 10 个整数的空间，不能只释放其中从第 2 个字节开始的部分，这会破坏内存管理的一致性。​

​
int main() {​
int *p = (int *)malloc(10 * sizeof(int));​
free(p + 2); // 错误，不能只释放部分内存​
return 0;​
}​

​
3、避免重复释放：对同一块动态内存多次释放会导致严重的错误，这就好比把同一间房子多次卖给不同的人，会造成内存管理的混乱。在释放内存后，应将指针置为NULL，以防止意外地再次使用已释放的指针。​

​
int main() {​
int *p = (int *)malloc(100);​
free(p);​
free(p); // 重复释放，会导致未定义行为​
return 0;​
}​

​
4、释放空指针是安全的：free(NULL)不会产生任何错误，这是free函数的一个特殊特性。因此，在动态分配内存之前，将相应的指针初始化为NULL是一个良好的编程习惯，这样可以避免因重复释放内存而导致的问题。​

堆内存管理的常见问题​

存存泄漏​

内存泄漏是 C 语言堆内存管理中一个常见且棘手的问题。内存泄漏指的是程序在动态分配了堆内存后，由于某些原因未能释放这些内存，导致这部分内存无法被再次利用，从而造成系统内存的浪费。随着程序运行时间的增长，内存泄漏问题如果得不到解决，会逐渐耗尽系统的可用内存，进而导致程序运行速度减慢，甚至引发系统崩溃等严重后果。常见的内存泄漏中，分配后未释放是最为直接的一种情况。例如：​
​

#include <stdio.h>​
#include <stdlib.h>​
​
void memoryLeakExample1() {​
int *ptr = (int *)malloc(10 * sizeof(int));​
// 使用ptr​
// 忘记释放ptr​
}​

在这个函数中，使用malloc分配了 10 个整数大小的内存空间，但在函数结束时没有调用free释放该内存，这就导致了内存泄漏。​
另一种常见的情况是在循环中内存分配未释放。比如：​
​

#include <stdio.h>​
#include <stdlib.h>​
​
void memoryLeakExample2() {​
for (int i = 0; i < 10; i++) {​
int *ptr = (int *)malloc(1 * sizeof(int));​
*ptr = i;​
// 每次循环都没有释放ptr​
}​
}​

​
在这个循环中，每次迭代都会分配一个新的内存块，但都没有释放，随着循环的进行，内存泄漏的问题会越来越严重。​
为了预防内存泄漏，开发者需要养成良好的编程习惯。首先，要牢记 “谁申请，谁释放” 的原则，在每次使用malloc、calloc或realloc分配内存后，一定要在合适的时机调用free释放内存。其次，可以在代码中添加注释，明确标记出内存分配和释放的位置，这样有助于提高代码的可读性和可维护性。

缓冲区溢出

缓冲区溢出就是当向一个缓冲区写入超过其容量的数据时，数据会溢出到相邻的内存区域，从而破坏其他数据或者影响程序的正常执行。​
在 C 语言中，字符串操作是最容易引发缓冲区溢出的场景之一。例如，strcpy函数在复制字符串时，如果目标缓冲区的大小不足以容纳源字符串，就会发生缓冲区溢出。看下面这个例子：​
​

#include <stdio.h>​
#include <string.h>​
​
void bufferOverflowExample() {​
char buffer[10];​
char *src = "This is a very long string";​
strcpy(buffer, src);​
// buffer的大小只有10个字符，而src的长度远远超过10，会导致缓冲区溢出​
printf("%s\n", buffer);​
}​

在这个例子中，buffer数组的大小为 10，而src指向的字符串长度远远超过 10 。当使用strcpy将src复制到buffer时，就会发生缓冲区溢出，src中超出buffer容量的字符会覆盖buffer后面的内存区域，可能会破坏其他重要的数据，甚至导致程序崩溃。​
缓冲区溢出会导致数据被破坏，程序在读取被覆盖的数据时会得到错误的结果，从而影响程序的正常逻辑。其次，缓冲区溢出还可能导致程序崩溃，因为溢出的数据可能会覆盖程序的关键指令或者内存管理信息，使得程序无法正常运行。更为严重的是，缓冲区溢出是一种常见的安全漏洞，恶意攻击者可以利用这个漏洞注入恶意代码，获取系统的控制权，从而进行各种恶意操作，如窃取敏感信息、破坏系统等。​
为了预防缓冲区溢出，可以采用一些技术和方法。首先要使用安全的函数来处理字符串操作，例如strncpy、snprintf等。这些函数会在复制或格式化字符串时，确保不会超出目标缓冲区的大小。以strncpy为例：​
​

#include <stdio.h>​
#include <string.h>​
​
void safeStringCopy() {​
char buffer[10];​
char *src = "This is a long string";​
strncpy(buffer, src, sizeof(buffer) - 1);​
buffer[sizeof(buffer) - 1] = '\0';​
// 使用strncpy复制src到buffer，最多复制sizeof(buffer) - 1个字符​
// 并手动添加字符串结束符'\0'​
printf("%s\n", buffer);​
}​

​
其次，在写入数据之前，要显式地检查目标缓冲区的大小，确保写入的数据不会超出缓冲区的容量。另外，尽量避免使用变长数组，因为变长数组的大小在运行时才确定，容易引发缓冲区溢出问题。还可以启用编译器的安全警告选项，如 GCC 的-Woverflow选项，它可以帮助开发者发现潜在的缓冲区溢出问题。