【快速上手C语言】第九章：探索 C 语言中的动态内存管理-从基础到高级技巧

最新推荐文章于 2024-10-27 19:55:47 发布
最新推荐文章于 2024-10-27 19:55:47 发布
阅读量791 收藏 14
点赞数 28
分类专栏： 快速上手C语言 文章标签： c语言 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2403_83044722/article/details/141389046
版权

        在嵌入式系统中，动态内存管理不仅是优化资源利用的必要技能，也是提升代码效率和系统稳定性的关键。本文将深入剖析 C 语言中的动态内存管理技术，从基本的内存分配与释放到复杂数据结构的实现，再到内存泄漏的调试与自定义内存管理器的设计，带你全面掌握这一重要领域。

内存的分配与释放：从基础函数到最佳实践

        在 C 语言中，动态内存管理主要依赖于 malloc、calloc、realloc 和 free 这四个函数。理解并正确使用这些函数，是写出高效、可靠代码的基础。

1.1 malloc 的使用： malloc 用于分配指定字节数的内存块，并返回指向该内存的指针。

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

int main() {
    int *ptr = (int *)malloc(5 * sizeof(int)); // 分配5个int大小的内存空间
    if (ptr == NULL) {
        printf("Memory allocation failed!\n");
        return 1;
    }

    for (int i = 0; i < 5; i++) {
        ptr[i] = i * 2;
    }

    for (int i = 0; i < 5; i++) {
        printf("%d ", ptr[i]);
    }
    printf("\n");

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

/* 运行结果：
0 2 4 6 8
*/

1.2 calloc 的使用： calloc 与 malloc 类似，但它分配的内存会自动初始化为零。

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

int main() {
    int *ptr = (int *)calloc(5, sizeof(int)); // 分配并初始化5个int大小的内存空间
    if (ptr == NULL) {
        printf("Memory allocation failed!\n");
        return 1;
    }

    for (int i = 0; i < 5; i++) {
        printf("%d ", ptr[i]);
    }
    printf("\n");

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

/* 运行结果：
0 0 0 0 0
*/

1.3 realloc 的使用： realloc 用于调整之前分配的内存块的大小。

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

int main() {
    int *ptr = (int *)malloc(3 * sizeof(int)); // 分配3个int大小的内存空间
    if (ptr == NULL) {
        printf("Memory allocation failed!\n");
        return 1;
    }

    for (int i = 0; i < 3; i++) {
        ptr[i] = i + 1;
    }

    ptr = (int *)realloc(ptr, 5 * sizeof(int)); // 扩展到5个int大小的内存空间
    if (ptr == NULL) {
        printf("Memory reallocation failed!\n");
        return 1;
    }

    for (int i = 3; i < 5; i++) {
        ptr[i] = i + 1;
    }

    for (int i = 0; i < 5; i++) {
        printf("%d ", ptr[i]);
    }
    printf("\n");

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

/* 运行结果：
1 2 3 4 5
*/

1.4 free 的使用： free 用于释放先前通过 malloc、calloc 或 realloc 分配的内存，以避免内存泄漏。

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

int main() {
    int *ptr = (int *)malloc(5 * sizeof(int)); // 分配5个int大小的内存空间
    if (ptr == NULL) {
        printf("Memory allocation failed!\n");
        return 1;
    }

    // 使用内存
    for (int i = 0; i < 5; i++) {
        ptr[i] = i + 1;
    }

    free(ptr); // 释放内存
    ptr = NULL; // 避免悬空指针
    return 0;
}

/* 运行结果：
无具体输出，但内存得到了有效释放。
*/
动态数据结构的实现：链表、栈和队列

        动态内存管理的强大之处在于它允许我们实现复杂的数据结构，例如链表、栈和队列。这些数据结构不仅灵活，而且可以根据需求动态扩展。

2.1 链表的实现： 链表是由节点组成的动态数据结构，每个节点包含数据和指向下一个节点的指针。

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

typedef struct Node {
    int data;
    struct Node* next;
} Node;

void append(Node** head_ref, int new_data) {
    Node* new_node = (Node*)malloc(sizeof(Node));
    Node* last = *head_ref;

    new_node->data = new_data;
    new_node->next = NULL;

    if (*head_ref == NULL) {
        *head_ref = new_node;
        return;
    }

    while (last->next != NULL) {
        last = last->next;
    }

    last->next = new_node;
}

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

int main() {
    Node* head = NULL;

    append(&head, 1);
    append(&head, 2);
    append(&head, 3);

    printList(head);

    // 释放链表内存
    Node* tmp;
    while (head != NULL) {
        tmp = head;
        head = head->next;
        free(tmp);
    }

    return 0;
}

/* 运行结果：
1 -> 2 -> 3 -> NULL
*/

2.2 栈的实现： 栈是一种后进先出（LIFO）的数据结构，可以使用链表来实现。

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

typedef struct Node {
    int data;
    struct Node* next;
} Node;

void push(Node** top_ref, int new_data) {
    Node* new_node = (Node*)malloc(sizeof(Node));
    new_node->data = new_data;
    new_node->next = *top_ref;
    *top_ref = new_node;
}

int pop(Node** top_ref) {
    if (*top_ref == NULL) {
        printf("Stack underflow\n");
        return -1;
    }
    Node* temp = *top_ref;
    *top_ref = (*top_ref)->next;
    int popped = temp->data;
    free(temp);
    return popped;
}

void printStack(Node* top) {
    while (top != NULL) {
        printf("%d -> ", top->data);
        top = top->next;
    }
    printf("NULL\n");
}

int main() {
    Node* stack = NULL;

    push(&stack, 10);
    push(&stack, 20);
    push(&stack, 30);

    printStack(stack);

    printf("Popped: %d\n", pop(&stack));
    printStack(stack);

    // 释放栈内存
    while (stack != NULL) {
        pop(&stack);
    }

    return 0;
}

/* 运行结果：
30 -> 20 -> 10 -> NULL
Popped: 30
20 -> 10 -> NULL
*/

2.3 队列的实现： 队列是一种先进先出（FIFO）的数据结构，可以使用链表来实现。

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

typedef struct Node {
    int data;
    struct Node* next;
} Node;

typedef struct Queue {
    Node *front, *rear;
} Queue;

Queue* createQueue() {
    Queue* q = (Queue*)malloc(sizeof(Queue));
    q->front = q->rear = NULL;
    return q;
}

void enqueue(Queue* q, int new_data) {
    Node* new_node = (Node*)malloc(sizeof(Node));
    new_node->data = new_data;
    new_node->next = NULL;

    if (q->rear == NULL) {
        q->front = q->rear = new_node;
        return;
    }

    q->rear->next = new_node;
    q->rear = new_node;
}

int dequeue(Queue* q) {
    if (q->front == NULL) {
        printf("Queue underflow\n");
        return -1;
    }

    Node* temp = q->front;
    int data = temp->data;
    q->front = q->front->next;

    if (q->front == NULL)
        q->rear = NULL;

    free(temp);
    return data;
}

void printQueue(Queue* q) {
    Node* temp = q->front;
    while (temp != NULL) {
        printf("%d -> ", temp->data);
        temp = temp->next;
    }
    printf("NULL\n");
}

int main() {
    Queue* q = createQueue();

    enqueue(q, 10);
    enqueue(q, 20);
    enqueue(q, 30);

    printQueue(q);

    printf("Dequeued: %d\n", dequeue(q));
    printQueue(q);

    // 释放队列内存
    while (q->front != NULL) {
        dequeue(q);
    }
    free(q);

    return 0;
}

/* 运行结果：
10 -> 20 -> 30 -> NULL
Dequeued: 10
20 -> 30 -> NULL
*/
内存泄漏与调试工具的使用

        内存泄漏是动态内存管理中的常见问题之一，特别是在嵌入式系统中，内存资源通常非常有限。避免内存泄漏和高效调试对于嵌入式开发者来说尤为重要。使用像 Valgrind 和 AddressSanitizer 这样的工具可以有效帮助检测内存问题。

自定义内存管理器的设计

        自定义内存管理器是针对特定应用优化内存使用的高级技巧。它允许开发者根据应用需求设计更加高效、针对性的内存分配策略。通过设计内存池、分区分配等技术，可以减少内存碎片、提高性能。

        下面是一个基本的内存池管理器的实现代码示例。这段代码展示了如何创建一个内存池，以及如何从该内存池中分配和释放内存块。

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

#define POOL_SIZE 1024  // 内存池大小，单位：字节

typedef struct MemoryPool {
    uint8_t pool[POOL_SIZE];  // 实际的内存池
    size_t free_offset;       // 当前空闲内存的偏移量
} MemoryPool;

// 初始化内存池
void initMemoryPool(MemoryPool* mp) {
    mp->free_offset = 0;  // 从头开始使用内存
}

// 从内存池中分配内存
void* poolAlloc(MemoryPool* mp, size_t size) {
    if (mp->free_offset + size > POOL_SIZE) {
        printf("Memory pool out of memory!\n");
        return NULL;  // 内存池不足以满足请求
    }

    void* ptr = mp->pool + mp->free_offset;  // 返回当前空闲内存的指针
    mp->free_offset += size;  // 更新空闲内存的偏移量
    return ptr;
}

// 重置内存池（模拟释放内存池中的所有内存）
void resetMemoryPool(MemoryPool* mp) {
    mp->free_offset = 0;  // 重置偏移量
}

// 内存池的使用示例
int main() {
    MemoryPool mp;
    initMemoryPool(&mp);

    int *a = (int *)poolAlloc(&mp, sizeof(int) * 10);  // 分配10个int大小的内存
    if (a == NULL) return 1;

    for (int i = 0; i < 10; i++) {
        a[i] = i * i;
        printf("a[%d] = %d\n", i, a[i]);
    }

    char *b = (char *)poolAlloc(&mp, 20);  // 分配20个字节的内存
    if (b == NULL) return 1;

    snprintf(b, 20, "Hello, Memory Pool");
    printf("String in memory pool: %s\n", b);

    // 重置内存池
    resetMemoryPool(&mp);

    // 重置后再次分配内存
    int *c = (int *)poolAlloc(&mp, sizeof(int) * 5);
    if (c == NULL) return 1;

    for (int i = 0; i < 5; i++) {
        c[i] = i + 1;
        printf("c[%d] = %d\n", i, c[i]);
    }

    return 0;
}

/* 运行结果：
a[0] = 0
a[1] = 1
a[2] = 4
a[3] = 9
a[4] = 16
a[5] = 25
a[6] = 36
a[7] = 49
a[8] = 64
a[9] = 81
String in memory pool: Hello, Memory Pool
c[0] = 1
c[1] = 2
c[2] = 3
c[3] = 4
c[4] = 5
*/

代码解析：

  1. MemoryPool 结构体:

    • pool 是一个大小固定的字节数组，用来模拟内存池。
    • free_offset 用于跟踪当前内存池中未使用部分的开始位置。

  2. initMemoryPool 函数:

    • 初始化内存池，将 free_offset 设为 0。

  3. poolAlloc 函数:

    • 负责从内存池中分配指定大小的内存。如果请求的内存超出了剩余的可用内存，返回 NULL 并打印错误消息。

  4. resetMemoryPool 函数:

    • 重置内存池，将 free_offset 重新设为 0，相当于释放了所有的内存。

  5. main 函数:

    • 展示了内存池的使用，通过 poolAlloc 函数从内存池中分配内存并进行读写操作，然后通过 resetMemoryPool 函数重置内存池后再次分配内存。

使用场景：

        这个内存池管理器非常适合内存资源有限的嵌入式系统，可以避免频繁的 malloc 和 free 调用导致的内存碎片问题。通过预先分配固定大小的内存块，可以实现更高效的内存管理。

        通过本文的讲解，您不仅可以掌握 C 语言中的动态内存管理基础，还能理解如何在实际开发中实现复杂的数据结构和自定义内存管理策略。希望这些知识能帮助您在嵌入式系统开发中写出更加高效、可靠的代码。

Seraphina_Lily
关注
专栏目录
C++ Qt零基础入门进阶与企业级项目实战教程与学习方法分享
琅嬛福地
09-21 3488
介绍Qt环境搭建、QtCreator / VS2019的基本使用方法，Qt整体架构、Qt信号机制，Qt内存管理等知识。
C语言系统化开发基础精讲
09-14
### C语言系统化开发基础精讲 #### 一、课程介绍与学习指南 - **课程目标**：本课程旨在帮助初学者系统地掌握C语言...- **设计哲学**：从C语言的设计理念出发，理解为什么数组是C语言中最基础且重要的数据结构之一。
快速上手C语言【下】（非常详细！！！)
a-clear-meaning的博客
10-19 1669
承接【上】，内容包括：指针，数组，函数，自定义类型，代码调试；每点都复合图解，非常详细，对新手小白极其友好，详细你仔细看完会有自己的收获！
掌握C语言：DEV C++编译器使用与技巧指南
weixin_29323977的博客
09-30 1258
本文还有配套的精品资源，点击获取 简介：本文深入探讨了C语言编译器DEV C++的特性和使用技巧，旨在为初学者和专业人士提供学习C语言的完整解决方案。包括安装、配置、基本操作和高级使用技巧，以及如何利用插件支持和版本控制等功能。文章还提供了一些在线学习资源和社区交流信息，帮助读者快速掌握DEV C++并提升编程能力。 1. DEV C++简介及其在学习C语言中的重...
C语言学习笔记：基础概念的入门
2401_85198806的博客
10-24 1132
你有没有遇到过这样的场景：家里的东西乱七八糟找不到，比如找钥匙时，虽然知道它在房间里，但具体在哪个抽屉就说不准了。幸好，家里有一个神奇的小助手（比如你的智能家居设备），你只要问它：“钥匙在哪儿？”它就能告诉你具体的抽屉位置，然后你就能打开抽屉拿到钥匙。在C语言中，指针就像这个小助手，它并不存储钥匙（数据）本身，而是告诉你钥匙存放的位置。指针记录了变量在内存中的位置（地址），让你能通过它找到并操作那个变量。
高级编程语言
Python老吕的博客
08-13 643
高级编程语言是一种接近人类语言的编程语言，它允许开发者以一种更自然和直观的方式来编写代码。与低级语言（如汇编语言或机器语言）相比，高级语言提供了更多的抽象层，隐藏了底层硬件的细节，使得编程更加容易和高效。易读性：语法结构类似于自然语言，易于理解。易写性：简化了编程过程，减少了编写代码所需的工作量。可移植性：代码通常不依赖于特定的硬件或操作系统。结构化：支持结构化编程，使得代码组织更加清晰。丰富的内置功能：提供了大量的内置函数和库，简化了常见任务的实现。
100天精通Golang（基础入门篇）——第2天：学习Go语言的前世今生：一门强大的编程语言的崛起
猫头虎：授渔优于赠鱼，兴趣引领智慧，探索之乐尤显珍贵。商务合作：Libin9iOak，共赴知识与乐趣的探索之旅！
06-06 5万+
随着软件开发的快速发展，我们需要一门新的编程语言来满足日益增长的需求。本文将介绍Go语言的诞生背景和发展历程，以及它在现代编程中的重要性。本文将深入探讨Go语言的前世今生，包括为何需要新的语言、谷歌工程师的20%时间、创始人以及Go的缔造与发展过程。还将介绍Go语言的logo和版本信息，并详细解析Go语言的核心特性以及它在并发编程、内存回收、网络编程等方面的应用。最后，我们将探讨Go语言的功能以及国内外知名企业和项目中使用Go语言的案例。
C语言学习篇之预告篇（C语言的学习计划和学习方法）
2301_80401264的博客
11-26 430
你们学习C语言的初心是什么？？迫不得已、自己的选择还是家中的要求呢？你们学习C语言的方法又是什么？你们又有哪些学习C语言的方法呢？？
牛逼！Java 从入门到精通，超全汇总版
热门推荐
程序员cxuan的个人主页
05-06 7万+
文章目录Java 基础Head First JavaJava 核心技术卷一Java 编程思想设计模式Head First 设计模式图解设计模式设计模式重学 Java 设计模式Java 进阶Java 并发编程实战Java 并发编程艺术Java 并发编程之美图解Java多线程设计模式JVM深入理解 Java 虚拟机Java 虚拟机规范HotSpot 实战自己动手写 Java 虚拟机MySQLMySQL 基础教程SQL 基础教程深入浅出 MySQLMySQL 必知必会SQL 必知必会高性能 MySQLMySQL
所有方向你要的资料干货这都有，从入门到实战！【CSDN宝藏资料图鉴第一期】
1_bit 的博客
06-08 2万+
前言 CSDN 是全球知名的开发者社区，创建于1999年，经过20来年的知识文档积累已然成为中文开发者的知识宝库；从基础的法入门到蜕变实战案例、从神秘前沿技术到清晰的实践步骤，可以说CSDN是你找寻资料的最佳宝库，只要你想得到，在这里就可以找得到！ 今天我们就来深拔一期有质量的专栏和资源，这些专栏作者可能有些是在校大学生、有些是某领域内的行内大牛，但并不影响他们的文章通俗易懂并且富有深度。从在校大学生我们看到了新一代的奋进，从领域大牛身上我们也看到了无私的技术分享，希望有质量的文章越来越多，共同为行业的进步
嵌入式系统开发基础——基于8位单片机的C语言程序设计(第二版)实验讲义.rar
10-24
通过这些实验，学生不仅能深入理解C语言在嵌入式环境中的应用，还能提高动手能力和问题解决能力，为更高级的嵌入式系统开发打下坚实基础。此外，实验讲义通常会提供详细的步骤指导和示例代码，帮助初学者快速上手。
C语言参考手册第五版_21天学通C语言
11-24
《21天学通C语言》则可能更注重实践和快速上手，通过实例和练习帮助初学者在短时间内掌握C语言的基本概念和编程技巧。书中的21天通常会按照循序渐进的方式安排课程，每天覆盖一个或几个关键知识点，让读者逐步建立...
C语言:水仙花树,要求三位以上的N位整数每位的N次方等于数本身,全部输出出来
Mcworld857的博客
10-27 179
int main()int n;int i=1;first*=10;i++;i=first;int t=i;do{int d=t%10;t/=10;int p=1;int j = 0;p*=d;j++;sum +=p;i++;return 0;
2024年，Rust开发语言，现在怎么样了?
LiangGang365的专栏
10-27 872
Rust到底好不好用，最终还是要看具体的业务场景应用。比如，目前用Rust来编写纯UI的前端，可能还不是很成熟。但在内存管理、安全性和性能优化等领域，Rust无疑是一种非常优秀的语言选择。国内华为、字节、百度、阿里、美团等在通用组件、基础平台系统都在使用rust，其他国内数据库厂商、交易所、理想汽车、小鹏汽车等，以及大量在区块链、游戏行业提供的远程职位
芋道管理后台，基于 vben 最新版本，最新的 vue3 vite4 ant-design-vue 4.0 typescript
10-31
ruoyi-vue-pro-vben 芋道管理后台，基于 vben 最新版本，最新的 vue3 vite4 ant-design-vue 4.0 typescript 语法进行重构开发，支持 springboot3 springcloud 版本
长春工程学院在四川2020-2024各专业最低录取分数及位次表.pdf
10-31
那些年，与你同分同位次的同学都去了哪里？全国各大学在四川2020-2024年各专业最低录取分数及录取位次数据，高考志愿必备参考数据
yolo算法-自动驾驶道路交通锥数据集-110张图像带标签-蓝黄色automatic-v62ff.zip
10-31
yolo系列算法目标检测数据集，包含标签，可以直接训练模型和验证测试，数据集已经划分好，适用yolov5,yolov8,yolov9,yolov7,yolov10,yolo11算法； 包含两种标签格:yolo格式（txt文件）和voc格式（xml文件），分别保存在两个文件夹中; yolo格式：<class> <x_center> <y_center> <width> <height>， 其中： <class> 是目标的类别索引（从0开始）。 <x_center> 和 <y_center> 是目标框中心点的x和y坐标，这些坐标是相对于图像宽度和高度的比例值，范围在0到1之间。 <width> 和 <height> 是目标框的宽度和高度，也是相对于图像宽度和高度的比例值
基于Java语言开发的fruits_manager_system水果管理系统设计源码
最新发布
11-01
该项目是一个基于Java语言开发的水果管理系统设计源码，包含53个文件，其中包括30个Java源文件、13个XML配置文件、6个JAR包文件、1个Git忽略文件、1个属性文件以及1个SQL脚本文件。此系统旨在用于期末答辩展示，展示了开发者对Java编程和系统设计的深入理解。
java回顾、知识整理、拾遗、面试_java-review.zip
10-31
java回顾、知识整理、拾遗、面试_java-review
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值