【C语言内存管理】第九章示例代码与演示

长天一色

于 2024-09-30 08:18:53 发布

阅读量590

点赞数 9

文章标签： c语言开发语言

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

版权

第九章示例代码与演示

在这一章中，我们将通过具体的代码示例来详细讲解静态内存分配、动态内存分配、内存泄漏检测和修复，以及复杂数据结构的内存管理。

1. 静态内存分配示例

静态内存分配是在编译时完成的，其分配的内存区域通常在栈上或全局/静态区。

#include <stdio.h>

// 全局变量
int globalVar = 10;

void staticMemoryExample() {
    // 局部变量 [1]
    int localVar = 20;
    // 静态局部变量 [2]
    static int staticLocalVar = 30;

    printf("Global Variable: %d\n", globalVar);
    printf("Local Variable: %d\n", localVar);
    printf("Static Local Variable: %d\n", staticLocalVar);

    // 修改静态局部变量的值 [3]
    staticLocalVar++;
}

int main() {
    staticMemoryExample();
    staticMemoryExample(); // 再次调用以查看静态局部变量的行为

    return 0;
}

详细说明

局部变量：在函数 staticMemoryExample 中定义的 int localVar = 20 是局部变量。它在每次调用函数时都会重新初始化，存储在栈上，并且在函数调用结束时释放。
静态局部变量：在函数 staticMemoryExample 中定义的 static int staticLocalVar = 30 是静态局部变量。它只在第一次调用函数时初始化，并且在后续调用中保持其值。该变量存储在全局/静态区，但作用域仅限于定义它的函数内部。
全局变量：在 main 函数之外定义的 int globalVar = 10 是全局变量。它可以在程序的任何部分访问，并在整个程序生命周期内存在。全局变量在程序开始时被分配内存，并在程序的整个运行期间保留其值。

额外说明

局部变量和静态局部变量的区别：局部变量每次函数调用都会重新分配和初始化，这意味着它的值在每次调用后不会保持。而静态局部变量在第一次初始化后会保留它的值，即使在函数返回后也是如此。
全局变量的作用：全局变量可以在整个程序范围内访问，但在多文件项目中，要小心全局变量的命名冲突。可以使用 extern 关键字在其他文件中声明全局变量。

通过这种解释方式，保证了对各个知识点的详细说明，并通过例子加以说明，从而帮助更好地理解静态内存分配的概念及其具体实现。

2. 动态内存分配示例

动态内存分配是在运行时进行的，使用堆内存。常用的动态内存分配函数有 malloc、calloc、realloc 和 free。

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

void dynamicMemoryExample() {
    int *arr;
    int n;
    
    printf("Enter number of elements: ");
    scanf("%d", &n);

    // 使用 malloc 分配内存 [1]
    arr = (int*)malloc(n * sizeof(int));
    
    // 检查内存是否成功分配 [2]
    if (arr == NULL) {
        printf("Memory not allocated.\n");
        exit(0);
    }

    // 为数组元素赋值 [3]
    for (int i = 0; i < n; i++) {
        arr[i] = i * 2;
    }

    // 打印数组元素 [4]
    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");

    // 释放动态内存 [5]
    free(arr);
}

int main() {
    dynamicMemoryExample();
    return 0;
}

详细说明：

malloc 函数用于分配指定大小的字节内存，并返回指向它的指针。例子中用 malloc 分配了一个整数数组。
若内存分配失败，malloc 返回 NULL。如果返回 NULL，程序将打印 “Memory not allocated.” 并终止。
在分配内存成功后，可以为数组元素赋值，这里将每个元素赋值为 i * 2。
打印数组元素，以确认内存分配和赋值是否成功。
使用 free 函数释放先前动态分配的内存，防止内存泄漏。

3. 内存泄漏检测与修复示例

内存泄漏发生在动态分配的内存没有被释放。可以使用工具如 Valgrind 或 AddressSanitizer 检测内存泄漏。

作用：帮助识别和修复内存泄漏问题，确保资源正确释放。
特点：
- 需要动态内存分配和释放函数如 malloc 和 free。
- 未释放的内存会导致资源浪费，严重时可能导致程序崩溃。
生命周期：从内存分配开始，直到显式调用 free 释放内存为止。

示例代码：带有内存泄漏问题

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

void memoryLeakExample() {
    int *ptr = (int*)malloc(sizeof(int) * 10);
    // 使用 malloc 分配内存但没有释放，导致内存泄漏 [1]
    if (ptr == NULL) {
        printf("Memory allocation failed\n");
        return;
    }
    // 在这里进行一些操作 [2]
    ptr[0] = 1;
    // 忘记使用 free(ptr); 
}

int main() {
    memoryLeakExample();
    return 0;
}

内存分配但未释放：int *ptr = (int*)malloc(sizeof(int) * 10); 使用 malloc 分配内存，但在函数结束前未调用 free 释放内存，导致内存泄漏。
操作内存：对分配的内存进行一些操作，如 ptr[0] = 1;。

修复后的示例代码

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

void memoryLeakExample() {
    int *ptr = (int*)malloc(sizeof(int) * 10);
    if (ptr == NULL) {
        printf("Memory allocation failed\n");
        return;
    }
    // 在这里进行一些操作
    ptr[0] = 1;

    // 修复内存泄漏，释放分配的内存 [3]
    free(ptr);
}

int main() {
    memoryLeakExample();
    return 0;
}

释放内存：调用 free(ptr); 在内存不再使用时释放分配的内存，避免内存泄漏问题。

通过以上修复示例，可以有效地释放动态分配的内存，避免内存泄漏，提高程序的稳定性和性能。

4. 复杂数据结构的内存管理

复杂数据结构（如链表、树等）在内存管理方面需要特别注意动态内存的分配与释放。以下是一个单链表的示例，展示了如何正确管理内存。

单链表示例

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

// 链表节点结构定义
struct Node {
    int data;
    struct Node* next;
};

// 创建新节点
struct Node* createNode(int data) {
    struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
    if (newNode == NULL) {
        printf("Memory allocation failed\n");
        exit(0);
    }
    newNode->data = data;
    newNode->next = NULL;
    return newNode;
}

// 打印链表
void printList(struct Node* head) {
    struct Node* current = head;
    while (current != NULL) {
        printf("%d -> ", current->data);
        current = current->next;
    }
    printf("NULL\n");
}

// 释放链表
void freeList(struct Node* head) {
    struct Node* current = head;
    struct Node* nextNode;
    while (current != NULL) {
        nextNode = current->next;
        free(current);
        current = nextNode;
    }
}

int main() {
    struct Node* head = createNode(1);
    head->next = createNode(2);
    head->next->next = createNode(3);

    printList(head);
    
    // 释放链表中的所有节点
    freeList(head);

    return 0;
}

详细说明：

创建新节点

struct Node* createNode(int data) {
    struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
    if (newNode == NULL) {
        printf("Memory allocation failed\n");
        exit(0);
    }
    newNode->data = data;
    newNode->next = NULL;
    return newNode;
}

使用 malloc 动态分配新节点的内存。
如果内存分配失败（即返回值为 NULL），打印错误信息并退出程序。

打印链表

void printList(struct Node* head) {
    struct Node* current = head;
    while (current != NULL) {
        printf("%d -> ", current->data);
        current = current->next;
    }
    printf("NULL\n");
}

遍历链表并打印每个节点的数据。
打印完整的链表后输出 NULL 表示链表结束。

释放链表

void freeList(struct Node* head) {
    struct Node* current = head;
    struct Node* nextNode;
    while (current != NULL) {
        nextNode = current->next;
        free(current);
        current = nextNode;
    }
}

遍历链表并逐个释放每个节点的内存。
防止内存泄漏，确保所有动态分配的内存都被正确释放。

使用示例：

int main() {
    struct Node* head = createNode(1);
    head->next = createNode(2);
    head->next->next = createNode(3);

    printList(head);
    
    // 释放链表中的所有节点
    freeList(head);

    return 0;
}