链表的调试技巧：打印链表辅助函数、使用断言、Valgrind检测内存泄漏

链表这东西，写起来爽，调起来可真是让人头大。我做了这么多年嵌入式，见过太多同事在链表上栽跟头——指针乱飞、内存泄漏、段错误，一个比一个刺激。今天我就把自己这些年积累的调试三板斧分享给你，希望能帮你少走些弯路。

一、打印链表辅助函数——让数据“可视化”

调试链表，第一步就是能看到它长什么样。我习惯在项目一开始就写一个打印函数，别嫌麻烦，后面能省你大量时间。

1. 基础打印函数

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

这个函数简单吧？但你别小看它。我在调试一个通信协议栈时，就靠这个函数发现了数据包顺序错乱的问题。打印出来一看，哦，插入逻辑写反了。

2. 增强版打印——带节点地址

有时候光看数据不够，还得看地址。特别是检查指针是否指向了不该指的地方。

void printListDebug(struct Node* head) {
    printf("链表调试信息:\n");
    int count = 0;
    while (head != NULL) {
        printf("[节点%d] 地址:%p 数据:%d 下一节点:%p\n",
               count, head, head->data, head->next);
        head = head->next;
        count++;
    }
    printf("共 %d 个节点\n", count);
}

二、使用断言——把错误扼杀在摇篮里

断言是什么？说白了就是“我坚信这里不会错，如果错了，程序立刻崩溃给我看”。这听起来有点暴力，但实际工作中，早崩溃比晚崩溃好一万倍。

1. 断言的基本用法

#include <assert.h>

void deleteNode(struct Node** head, int key) {
    assert(head != NULL);      // 头指针不能为空
    assert(*head != NULL);     // 链表不能为空
    
    struct Node* temp = *head;
    struct Node* prev = NULL;
    
    // 查找要删除的节点
    while (temp != NULL && temp->data != key) {
        prev = temp;
        temp = temp->next;
    }
    
    assert(temp != NULL);      // 没找到？那肯定有问题
    
    if (prev == NULL) {
        *head = temp->next;    // 删除头节点
    } else {
        prev->next = temp->next;
    }
    free(temp);
}

你看，我在三个关键位置加了断言。为什么要这么做？

• 第一处：防止有人传了个野指针进来
• 第二处：防止对空链表执行删除操作
• 第三处：防止要删除的节点根本不存在

2. 自定义断言——更友好的错误提示

标准assert的报错信息有时候不够直观。我习惯自己封装一个：

#define ASSERT(cond, msg) \
    do { \
        if (!(cond)) { \
            fprintf(stderr, "断言失败: %s, 文件:%s, 行:%d\n", \
                    msg, __FILE__, __LINE__); \
            abort(); \
        } \
    } while(0)

// 使用示例
void insertAtHead(struct Node** head, int data) {
    ASSERT(head != NULL, "头指针为NULL");
    
    struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
    ASSERT(newNode != NULL, "内存分配失败");
    
    newNode->data = data;
    newNode->next = *head;
    *head = newNode;
}

嗯，这里要注意，do { ... } while(0) 这个写法是为了让宏能像普通函数一样使用，加分号也不会出问题。

三、Valgrind检测内存泄漏——你的内存去哪了？

链表操作中，内存泄漏是家常便饭。你new了一个节点，忘了free，程序跑着跑着内存就爆了。在嵌入式系统里，这可能是致命的。

Valgrind就是专门干这个的。它像一个侦探，能追踪你程序里每一块内存的来龙去脉。

1. 基本使用

// 编译时加上 -g 选项，保留调试信息
gcc -g -o myprogram myprogram.c

// 运行Valgrind
valgrind --leak-check=full ./myprogram

2. 一个典型的内存泄漏例子

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

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

void createLeak() {
    struct Node* head = (struct Node*)malloc(sizeof(struct Node));
    head->data = 10;
    head->next = NULL;
    // 忘记free(head)了！
}

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

运行Valgrind后，你会看到类似这样的输出：

==12345== 16 bytes in 1 blocks are definitely lost in loss record 1 of 1
==12345==    at 0x4C2B800: malloc (vg_replace_malloc.c:299)
==12345==    by 0x40052E: createLeak (test.c:9)
==12345==    by 0x40053E: main (test.c:15)

看到了吗？它清清楚楚地告诉你：第9行malloc的内存，在第15行调用后就没有释放。这就是证据。

3. Valgrind常用选项

选项	作用	我的建议
--leak-check=full	显示详细的内存泄漏信息	必加，不然等于没查
--show-leak-kinds=all	显示所有类型的泄漏	建议加上，别漏掉
--track-origins=yes	追踪未初始化值的来源	调试疑难杂症时用
--log-file=val.log	输出到文件	输出太长时用，方便分析

四、知识体系总览

下面这张图，是我对链表调试技巧的总结。你看一眼，心里就有谱了。

五、实战建议——把这些技巧用起来

光看不练，等于白学。我给你一个具体的行动方案：

1. 写链表代码时，先写打印函数。别等出问题了再补，那时候你已经焦头烂额了。
2. 每个链表操作函数，开头加断言。检查传入参数是否合法。这花不了你30秒，但能省你3小时。
3. 每次修改链表后，用Valgrind跑一遍。养成习惯，就像写完代码要编译一样自然。

好了，关于链表调试，我就说这么多。记住，调试不是惩罚，而是帮你写出更健壮代码的过程。下次遇到链表bug，别慌，拿出这三板斧，一个一个试，问题总会解决的。

---