C语言——动态内存管理

康熙38bdc

于 2023-12-08 09:00:47 发布

阅读量158

点赞数 7

分类专栏： C语言基础知识文章标签： c语言开发语言

本文链接：https://blog.csdn.net/wxk2227814847/article/details/134835556

版权

C语言基础知识专栏收录该内容

25 篇文章 2 订阅

订阅专栏

本文详细介绍了C语言中动态内存管理的核心概念，包括内存分配函数malloc、calloc、realloc的区别与用法，以及free函数的释放操作。文章还涵盖了柔性数组、内存区域划分、常见错误和内存管理的最佳实践。

摘要由CSDN通过智能技术生成

0.前言

在C语言中，动态内存管理是一项重要的任务，允许程序在运行时分配和释放内存。这种机制使得程序更加灵活，能够处理不确定大小的数据结构。本博客将介绍C语言中动态内存管理的各个方面，包括分配、释放、以及常见的错误和柔性数组的使用。

1.为什么有动态内存分配

在C语言中，内存的分配和管理是编程过程中至关重要的一环。与静态内存分配相对应的是动态内存分配，而动态内存分配的存在主要是为了解决以下几个问题：

在程序运行过程中，有时无法提前确定需要多大的内存空间。例如，用户输入的数据大小可能会变化，或者程序需要动态地调整数据结构的大小以应对不同的情况。动态内存分配允许程序在运行时根据需要分配或释放内存，因此更适应不确定大小的情况。
动态内存分配提供了更大的灵活性，使得程序能够根据实际需求动态地管理内存。这对于处理动态数据结构（如链表、树、图等）或者在运行时创建新的对象非常有帮助。通过动态内存分配，程序可以更好地适应变化的运行时条件，提高了代码的通用性和可复用性。
静态内存分配在编译时确定内存大小，这可能导致内存浪费。例如，如果为一个数组分配了100个元素的空间，但实际只使用了其中的50个，那么就浪费了50个元素的内存。动态内存分配可以根据实际需求分配精确的内存空间，避免了不必要的内存浪费。
动态内存分配允许程序员明确地控制内存的生命周期。通过手动分配和释放内存，程序可以在需要时分配内存，在不需要时及时释放，防止内存泄漏。这样的控制对于长时间运行的程序或者资源有限的嵌入式系统至关重要。
动态内存分配还允许数据在函数调用之间保持持久性。静态内存分配的变量在函数调用结束时会被销毁，而动态内存分配的数据可以在函数调用结束后继续存在，提供了一种跨函数和跨作用域的数据共享方式。

2.malloc

malloc（Memory Allocation）是C语言中用于动态分配内存的函数之一。它的主要作用是在程序运行时从堆（heap）中分配一块指定大小的内存空间，并返回一个指向该内存块的指针。以下是关于malloc的详细介绍：

2.1 函数原型

void *malloc(size_t size);

size_t 是一个无符号整数类型，通常是unsigned int或unsigned long的别名，用于表示要分配的内存块的大小。

2.2 功能和用法

malloc函数的主要功能是分配指定大小的内存块，并返回一个指向该内存块的指针。
如果分配成功，返回的指针指向的内存块是未初始化的，其中的内容是不确定的。
如果分配失败，返回NULL指针，表示未能成功分配所需的内存空间。
如果参数size为0，malloc的行为是C语言标准未定义的，具体取决于编译器。

2.3 示例用法

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

int main() 
{
    // 分配包含5个整数的内存块
    int *array = (int *)malloc(5 * sizeof(int));

    if (array != NULL) 
    {
        // 使用分配的内存
        for (int i = 0; i < 5; i++) 
        {
            array[i] = i * 2;
        }

        // 打印分配的内存内容
        for (int i = 0; i < 5; i++) 
        {
            printf("%d ", array[i]);
        }

        // 释放分配的内存
        free(array);
    } 
    else 
    {
        // 内存分配失败的处理
        fprintf(stderr, "内存分配失败\n");
    }
    return 0;
}

2.4 注意事项

在使用分配的内存之前，务必检查返回的指针是否为NULL，以确保内存分配成功。
使用malloc分配的内存块是未初始化的，因此在使用之前最好进行适当的初始化。
为了防止内存泄漏，使用完分配的内存后，应该调用free函数释放该内存。

2.5 动态内存分配的生命周期

动态分配的内存块生命周期通常是在调用free函数时结束。程序员有责任确保在不再需要动态分配的内存时及时释放它，以避免内存泄漏问题。

2.6 返回类型

malloc返回一个void类型的指针，因为它不知道要分配的内存的具体类型。在使用时，需要将其强制转换为适当的类型。

3.free

在C语言中，free函数用于释放由动态内存分配函数（如malloc、calloc、realloc等）分配的内存。以下是关于free函数的详细介绍：

3.1 函数原型

void free(void *ptr);

void *ptr 是指向要释放的内存块的指针。

3.2 功能和用法

free函数的主要功能是释放先前由动态内存分配函数分配的内存。
释放的内存会返回给系统的内存池，以便后续的动态分配使用。
被释放的内存块不再属于程序，因此在调用free之后，不应再使用指向该内存块的指针。

3.3 示例用法

#include <stdlib.h>

int main() 
{
    // 分配动态内存
    int *array = (int *)malloc(5 * sizeof(int));

    if (array != NULL) 
    {
        // 使用分配的内存

        // 释放动态内存
        free(array);
    }

    return 0;
}

3.4 注意事项

调用free之前，应确保传递给它的指针是通过动态内存分配函数获得的。释放非动态分配的内存或重复释放同一块内存可能导致程序崩溃或未定义的行为。
释放后的指针不再有效，应该避免在释放后继续使用它，以防止悬空指针的问题。
为了避免悬空指针，释放后将指针设置为NULL是一个良好的实践。

3.5 动态内存分配的生命周期

free函数标志着动态分配的内存块的生命周期结束。程序员有责任在不再需要动态分配的内存时及时调用free，以防止内存泄漏问题。

3.6 返回类型

free函数没有返回值（返回类型为void），因为它只负责释放内存，而不提供任何结果或状态信息。

3.7 与NULL指针的搭配

在释放内存后，将指针设置为NULL是一种良好的实践，以避免悬空指针的问题。例如：

free(array);
array = NULL;

4.calloc

calloc（Contiguous Allocation）是C语言中用于动态分配内存的函数之一，与malloc类似。calloc主要用于分配一块指定数量和大小的内存块，并且与malloc不同的是，calloc还会将分配的内存块的每个字节初始化为零。以下是有关calloc的详细介绍：

4.1 函数原型

void *calloc(size_t num_elements, size_t element_size);

size_t num_elements：要分配的元素数量。
size_t element_size：每个元素的大小（以字节为单位）。

4.2 功能和用法

calloc函数的主要功能是分配一块内存，大小为num_elements * element_size字节，并将分配的内存块的每个字节初始化为零。
如果分配成功，返回指向该内存块的指针；如果分配失败，返回NULL指针。

4.3 示例用法

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

int main() 
{
    // 分配包含5个整数的内存块，并初始化为零
    int *array = (int *)calloc(5, sizeof(int));

    if (array != NULL) 
    {
        // 使用分配的内存

        // 打印分配的内存内容
        for (int i = 0; i < 5; i++) 
        {
            printf("%d ", array[i]);
        }

        // 释放分配的内存
        free(array);
    } 
    else 
    {
        // 内存分配失败的处理
        fprintf(stderr, "内存分配失败\n");
    }

    return 0;
}

4.4 注意事项

与malloc不同，calloc会在分配内存的同时将每个字节初始化为零。这意味着使用calloc分配的内存块中的所有元素都会被初始化为零值。
与其他动态内存分配函数一样，使用完内存后应该调用free函数释放该内存，以避免内存泄漏。

4.5 返回类型

calloc返回一个指向分配的内存块的指针。由于它无法确定分配的内存块的具体类型，因此返回类型是void指针，通常需要显式转换为适当的类型。

4.6 动态内存分配的生命周期

使用calloc分配的内存块的生命周期与其他动态分配的内存一样，需要在不再需要时调用free函数进行释放。

4.7 与`malloc`的比较

calloc与malloc相似，但是多了一个参数，用于指定要分配的元素数量，并且会将分配的内存初始化为零。在某些情况下，这可以简化代码，避免未初始化的内存值导致的问题。

5.realloc

realloc（Reallocate）是C语言中用于重新分配动态分配内存的函数。它可以用于扩大或缩小先前由动态内存分配函数分配的内存块的大小。以下是关于realloc的详细介绍：

5.1 函数原型

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

void *ptr：指向先前动态分配的内存块的指针。
size_t new_size：新的内存块大小（以字节为单位）。

5.2 功能和用法

realloc函数的主要功能是重新分配先前由动态内存分配函数分配的内存块的大小。
如果新的大小大于原来的大小，会在原有内存块的基础上扩大内存。如果新的大小小于原来的大小，会截断内存块，保留前部分。
返回指向重新分配后的内存块的指针，如果分配失败或者无法满足新的大小，则返回NULL指针。在这种情况下，原有的内存块保持不变。

5.3 示例用法

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

int main() 
{
    // 分配包含3个整数的内存块
    int *array = (int *)malloc(3 * sizeof(int));

    if (array != NULL) 
    {
        // 使用分配的内存

        // 重新分配内存，扩大到包含5个整数的内存块
        int *new_array = (int *)realloc(array, 5 * sizeof(int));

        if (new_array != NULL) 
        {
            // 使用重新分配的内存

            // 释放重新分配前的内存
            free(new_array);
        } 
        else 
        {
            // 重新分配失败的处理
            fprintf(stderr, "内存重新分配失败\n");

            // 原有的内存仍然有效，可以继续使用

            // 释放原有的内存
            free(array);
        }
    } 
    else 
    {
        // 内存分配失败的处理
        fprintf(stderr, "内存分配失败\n");
    }

    return 0;
}

5.4 注意事项

在调用realloc函数之前，必须通过动态内存分配函数（如malloc、calloc、realloc等）获得一个有效的指针。
调用realloc函数后，如果返回的指针与传递给它的原始指针相同，则说明内存块未移动。否则，返回的指针指向新分配的内存块，而原有的内存块已经被释放。
当调用realloc函数时，新的内存块大小可以大于、等于或小于原来的大小。如果新的大小大于原来的大小，而且新的内存块与原来的内存块有重叠部分，那么行为是未定义的。

5.5 返回类型

realloc返回一个指向重新分配后的内存块的指针。与其他动态内存分配函数一样，返回类型是void指针，通常需要显式转换为适当的类型。

5.6 动态内存分配的生命周期

使用realloc重新分配内存块后，程序员仍然有责任在不再需要内存时调用free释放它。如果realloc失败，原有的内存块仍然有效，需要手动释放。

5.7 与`malloc`和`calloc`的比较

realloc可以在不使用额外变量的情况下调整内存大小，而malloc和calloc通常需要一个额外的指针来存储新分配的内存块。
realloc的使用场景通常是在动态地调整数组或缓冲区的大小，以适应变化的需求。

6.常见错误

在C语言中，动态内存管理涉及到一些常见的错误，如果不注意这些问题，可能导致程序运行时的异常行为、内存泄漏等问题。以下是一些常见的动态内存管理错误及其详细介绍：

6.1对NULL指针的解引用

问题描述：

int *ptr = (int *)malloc((size_t)-1); // 假设malloc字节数过多导致返回NULL
*ptr = 42;  // 对NULL指针进行解引用

修正后代码：

int *ptr = (int *)malloc((size_t)-1);
if (ptr != NULL) 
{
    *ptr = 42;
    // 其他操作
} 
else 
{
    // 错误处理
    fprintf(stderr, "尝试对NULL指针解引用\n");
}

在实际情况中，malloc不太可能返回NULL，因为它通常在分配失败时会抛出异常或终止程序。此处将malloc返回NULL的情况设定为特殊场景。修正后的代码添加了对指针是否为NULL的检查，以避免解引用NULL指针带来的问题。

6.2对动态开辟空间越界访问

问题描述：

int *array = (int *)malloc(5 * sizeof(int));
int value = array[5];  // 越界访问

修正后代码：

int *array = (int *)malloc(5 * sizeof(int));
if (array != NULL) 
{
    // 正确的访问方式
    int value = array[4];
    // 其他操作
} 
else 
{
    // 错误处理
    fprintf(stderr, "内存分配失败\n");
}

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

问题描述：

int stackVar;
free(&stackVar);  // 对栈上分配的内存使用free

注意：

不应该对栈上分配的内存使用free
栈上的内存由系统管理，不需要手动释放

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

问题描述：

int *array = (int *)malloc(5 * sizeof(int));
free(&array[2]);  // 释放动态内存的一部分

修正后代码：

int *array = (int *)malloc(5 * sizeof(int));
free(array);  // 应该释放整个动态内存块

6.5多次释放同一动态内存

问题描述：

int *ptr = (int *)malloc(sizeof(int));
free(ptr);
free(ptr);  // 多次释放同一块内存

修正后代码：

int *ptr = (int *)malloc(sizeof(int));
free(ptr);
ptr = NULL;  // 将指针设置为NULL，避免悬空指针

6.6动态开辟内存未释放

问题描述：

int *ptr = (int *)malloc(sizeof(int));
// 忘记调用free释放内存

修正后代码：

int *ptr = (int *)malloc(sizeof(int));
// 使用动态分配的内存
// ...
// 在不再需要时释放内存
free(ptr);

注意：

动态分配的内存未被释放会导致内存泄漏。内存泄漏是指程序在运行时分配了一块内存，但在不再需要这块内存时没有释放它，导致程序持续占用内存资源。修正后的代码加入了 free(ptr)，确保在不再需要动态分配的内存时及时释放，以避免内存泄漏。内存泄漏可能会导致程序占用的内存越来越多，最终影响程序性能并导致系统资源耗尽。因此，正确释放动态分配的内存是良好的编程习惯。

7.柔性数组

柔性数组（Flexible Array Member）是C语言中一种特殊的数组形式，它允许在结构体的末尾定义一个长度不确定的数组。柔性数组的引入使得结构体可以包含一个变长的数组，从而更灵活地处理动态分配内存的情况。

7.1柔性数组的特点

定义位置： 柔性数组定义在结构体的末尾，作为结构体的最后一个成员。
长度不确定： 柔性数组的长度不在结构体中指定，而是在运行时根据需要动态分配内存。
末尾标记： 柔性数组后面不能再有其他成员，其长度由数组实际分配的内存决定。

7.2柔性数组的使用

定义结构体包含柔性数组：

struct FlexArrayStruct {
    int fixedMember;
    // 其他固定大小的成员
    // ...

    // 柔性数组，长度在运行时确定
    // 注意：柔性数组后不能再有其他成员
    int flexArray[];
};

动态分配内存：

struct FlexArrayStruct *ptr;

// 分配结构体和柔性数组的内存
ptr = malloc(sizeof(struct FlexArrayStruct) + sizeof(int) * arraySize);

if (ptr != NULL) 
{
    // 使用柔性数组
    for (int i = 0; i < arraySize; i++) 
    {
        ptr->flexArray[i] = i * 2;
    }

    // 其他操作

    // 释放内存
    free(ptr);
}

7.3柔性数组的优势

我们不妨先看一下柔性数组的“模仿版”代码：

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

typedef struct st_type {
    int i;
    int *p_a;
} type_a;

int main() {
    type_a *p = (type_a *)malloc(sizeof(type_a));
    p->i = 100;
    p->p_a = (int *)malloc(p->i * sizeof(int));

    // 业务处理
    for (int i = 0; i < 100; i++) {
        p->p_a[i] = i;
    }

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

    return 0;
}

代码功能：

定义了一个结构体 type_a，包含一个整型成员 i 和一个指向整型的指针成员 p_a。
在 main 函数中，使用 malloc 分配了 type_a 结构体的内存，并为 p_a 成员分配了一个大小为 i 的整型数组。
进行业务处理，将数组初始化。
最后释放动态分配的内存，确保不会发生内存泄漏。

然后我们再聊一聊柔性数组相对于以上代码的优势所在。

内存管理更高效： 柔性数组将整个结构体和数组一起分配内存，减少了两个不同内存块的分配和释放，提高了内存管理效率。
内存紧凑： 柔性数组使得整个结构体的内存布局更加紧凑，避免了内存碎片的可能性。
简化代码逻辑： 柔性数组不需要额外的指针引用，代码更加简洁，避免了额外的指针操作。
直观的访问方式： 可以直接使用结构体操作符访问数组元素，使代码更加清晰和直观。
避免指针悬空问题： 在使用柔性数组时，结构体的整个内存块一起分配和释放，避免了可能出现的指针悬空问题。而在代码2中，可能会出现忘记释放数组或忘记将指针置为NULL的问题。