【C语言内存管理】第三章堆内存管理

长天一色

已于 2024-09-29 20:37:47 修改

阅读量128

点赞数 3

分类专栏： C 文章标签： c语言开发语言

于 2024-09-29 20:14:00 首次发布

本文链接：https://blog.csdn.net/fjw12998/article/details/142642784

版权

C 专栏收录该内容

13 篇文章 0 订阅

订阅专栏

第三章堆内存管理

在C语言中，堆内存管理是较为灵活的内存管理方式之一，它允许程序在运行时根据需求动态分配和释放内存，与静态分配相比更为灵活。下面我们对堆内存管理进行详细讲解。

1. 动态内存分配函数

在C语言中，有四个标准函数用于动态内存分配和释放：

malloc: 分配指定大小的字节，并返回指向该内存块的指针。
calloc: 分配包含给定数量的元素且每个元素大小为一个指定字节数的内存区域，并初始化为0。
realloc: 调整以前分配的内存块的大小。
free: 释放以前分配的内存块。

`malloc`函数

#include <stdlib.h>

int* allocateArray(int size) {
    int* array = (int*)malloc(size * sizeof(int));
    if (array == NULL) {
        // 处理内存分配失败情况
        printf("Memory allocation failed.\n");
        exit(1);
    }
    return array;
}

malloc分配了一个新的内存块，并返回指向该内存块的指针。
如果内存分配失败，malloc返回 NULL。

`calloc`函数

#include <stdlib.h>

int* initializeArray(int count) {
    int* array = (int*)calloc(count, sizeof(int));
    if (array == NULL) {
        // 处理内存分配失败情况
        printf("Memory allocation failed.\n");
        exit(1);
    }
    return array;
}

calloc函数分配内存并将其初始化为0。
参数的第一个值是元素个数，第二个值是每个元素的大小。

`realloc`函数

#include <stdlib.h>

int* resizeArray(int* array, int newSize) {
    int* newArray = (int*)realloc(array, newSize * sizeof(int));
    if (newArray == NULL) {
        // 处理内存分配失败情况
        printf("Memory reallocation failed.\n");
        free(array); // 避免内存泄漏
        exit(1);
    }
    return newArray;
}

realloc函数调整给定内存块的大小。
如果新大小大于旧大小，realloc可能在新位置分配内存，并复制数据，如果新大小小于旧大小，数据被截断。

`free`函数

#include <stdlib.h>

void deallocateArray(int* array) {
    free(array);
}

free函数释放之前由malloc, calloc 或 realloc 分配的内存。
释放后，指针不再指向有效内存区域。通常将指针设置为 NULL 避免悬空指针（即 Dangling Pointer）。

2. 静态内存与动态内存的对比

静态内存分配
- 确定性：内存大小在编译时确定。
- 位置：使用全局变量或局部变量在栈上分配。
- 管理：内存由编译器自动管理，不需要显式释放。
动态内存分配
- 灵活性：内存大小在运行时确定。
- 位置：使用 malloc, calloc, realloc 在堆上分配。
- 管理：需要显式调用 free 释放内存，防止内存泄漏。

3. 动态内存管理实践

内存分配与释放

以下示例展示如何动态分配和释放内存：

#include <stdlib.h>

void example() {
    int* array = (int*) malloc(10 * sizeof(int)); // 动态分配内存 [1]
    if (!array) {
        // 处理内存分配失败
    }
    // 使用数组进行某些操作...
    free(array); // 释放内存 [2]
}

内存分配：malloc 用于在堆上分配一片连续内存。程序员需要检查分配是否成功，避免使用 NULL 指针。
内存释放：free 函数用于释放之前分配的内存，以防止内存泄漏。

内存泄漏的预防

内存泄漏是指程序无法再访问某块内存，但该内存未被释放，导致内存浪费。预防内存泄漏的要点包括：

确保每块动态分配的内存都有对应的 free 调用。
使用工具如 Valgrind 检测内存泄漏。

示例代码：

#include <stdlib.h>

void memoryLeakExample() {
    int* leakyArray = (int*)malloc(10 * sizeof(int));
    // 忘记释放内存，造成内存泄漏 [3]
}

void noMemoryLeakExample() {
    int* array = (int*)malloc(10 * sizeof(int));
    if (!array) return;
    // 使用数组进行某些操作...
    free(array); // 释放内存，避免泄漏 [4]
}

内存泄漏：leakyArray 在函数结束时没有被释放，导致内存泄漏。
内存释放：调用 free 释放动态分配的内存，避免内存泄漏。

内存碎片化问题及优化

内存碎片化是指堆内存中由于频繁的分配和释放而产生很多小而分散的内存块。解决方案包括：

使用内存池：提前分配一大块内存，并根据需求从内存池中取。
合并空闲块：实现自己的内存管理器，将相邻的空闲内存块合并。

示例代码：

#include <stdlib.h>

void memoryFragmentationSolution() {
    // 简化的内存池使用示例 [5]
    static char memoryPool[1024];
    static int poolIndex = 0;

    void* customMalloc(size_t size) {
        if (poolIndex + size > sizeof(memoryPool)) {
            return NULL; // 内存不足 [6]
        }
        void* ptr = &memoryPool[poolIndex];
        poolIndex += size;
        return ptr;
    }

    // 使用自定义的 malloc [7]
    int* array = (int*)customMalloc(10 * sizeof(int));
    if (array == NULL) {
        printf("Memory allocation failed.\n");
    } else {
        // 使用数组进行某些操作...
    }
}