9. 空指针与野指针：内存世界的幽灵与陷阱

指针，是C语言的灵魂，也是无数崩溃的根源。我做了这么多年安全审计，见过最多的漏洞类型，指针问题绝对排前三。今天咱们就来聊聊指针世界里最让人头疼的四个“幽灵”：空指针、野指针、悬空指针，还有释放后使用。

说白了，这些问题都是同一个本质：你手里拿着的地址，已经不是你以为的那个有效地址了。你想想看，你拿着一个错误的地址去读写内存，不出事才怪。

9.1 空指针解引用：最经典的崩溃

空指针，就是值为NULL的指针。NULL在C语言中通常定义为((void*)0)，表示“不指向任何地方”。

空指针解引用，说白了就是你对一个NULL指针做了*操作或者->操作。结果是什么？段错误（Segmentation Fault），程序直接崩掉。

我记得有一次，一个同事调试了整整一个下午，就为了找一个空指针。代码逻辑是这样的：

// 错误示例：空指针解引用
#include <stdio.h>
#include <stdlib.h>

void process_data(int *ptr) {
    // 这里没有检查ptr是否为NULL！
    *ptr = 42;  // 如果ptr是NULL，这里就崩了
}

int main() {
    int *p = NULL;
    process_data(p);  // 传入空指针
    return 0;
}

为什么会这样？因为NULL地址（0x0）是操作系统保护的区域，用户程序根本不能访问。你强行去写，内核直接给你发SIGSEGV信号，程序就挂了。

我个人习惯是：每次使用指针前，都做一次NULL检查。这不是矫情，这是保命。

// 正确做法：先检查，再使用
void process_data(int *ptr) {
    if (ptr == NULL) {
        fprintf(stderr, "错误：传入空指针\n");
        return;  // 或者返回错误码
    }
    *ptr = 42;
}

9.2 未初始化指针：你不知道它指向哪

未初始化指针，比空指针更危险。空指针至少是确定的NULL，而未初始化指针的值是随机的——它可能指向任何地方。

你想想看，一个局部变量如果没有显式初始化，它的值就是栈上残留的垃圾数据。这个“垃圾地址”可能指向你的数据区、代码区，甚至是操作系统内核空间。

// 危险示例：未初始化指针
void dangerous_func() {
    int *p;  // 未初始化！p的值是随机的
    *p = 100;  // 写入一个未知地址，后果不可预测
}

我在项目中遇到过这样的bug：一个函数里声明了指针变量，但忘记初始化。在某些编译优化下，这个指针恰好指向了另一个函数的局部变量，导致数据被莫名其妙地修改。调试了三天才找到原因。

避坑指南：声明指针的同时就初始化。如果暂时没有有效地址，就初始化为NULL。

// 安全做法：声明时初始化
void safe_func() {
    int *p = NULL;  // 明确初始化为空
    // ... 后续代码中，如果p被赋值了有效地址，再使用
    if (p != NULL) {
        *p = 100;
    }
}

9.3 悬空指针：指向已释放的内存

悬空指针，也叫dangling pointer。它指向的内存已经被释放了，但指针变量里还保留着那个地址。这时候你去访问它，就是典型的“释放后使用”（use-after-free）。

为什么危险？因为那块内存被释放后，可能已经被分配给其他变量使用了。你通过悬空指针去读写，实际上是在破坏别人的数据。

// 悬空指针示例
#include <stdlib.h>

int *create_int() {
    int *p = (int*)malloc(sizeof(int));
    *p = 42;
    return p;
}

void use_after_free() {
    int *ptr = create_int();
    free(ptr);  // 释放内存
    // 此时ptr变成悬空指针
    *ptr = 100;  // 危险！释放后使用
}

我记得有一次做代码审查，看到一段代码在free之后没有把指针置为NULL。我当时就说：“这里有个use-after-free的风险。”对方还不信，结果测试的时候果然偶发崩溃。

我个人习惯是：free之后立即将指针置为NULL。这样即使后续误用了，也会因为空指针检查而提前暴露问题，而不是悄无声息地破坏数据。

// 安全做法：free后置空
void safe_use() {
    int *ptr = (int*)malloc(sizeof(int));
    if (ptr == NULL) return;
    
    *ptr = 42;
    free(ptr);
    ptr = NULL;  // 关键：置空
    
    // 后续如果误用ptr，会触发空指针检查
    if (ptr != NULL) {
        *ptr = 100;  // 不会执行到这里
    }
}

9.4 释放后使用（Use-After-Free）：最隐蔽的漏洞

释放后使用是悬空指针的“升级版”。它不仅仅是访问已释放的内存，更常见的是在复杂的数据结构中，一个对象被释放了，但还有其他指针引用着它。

这种漏洞在C++中尤其常见（比如虚函数表被破坏），但在C语言中同样致命。攻击者可以利用use-after-free漏洞实现任意代码执行。

// Use-After-Free 典型场景
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct {
    char name[32];
    void (*callback)(void);
} UserData;

void malicious_callback() {
    printf("恶意代码被执行！\n");
}

int main() {
    UserData *user = (UserData*)malloc(sizeof(UserData));
    if (user == NULL) return -1;
    
    strcpy(user->name, "Alice");
    user->callback = NULL;
    
    free(user);  // 释放user
    
    // 攻击者可能在这里分配另一个对象，覆盖了user的内存
    UserData *attacker = (UserData*)malloc(sizeof(UserData));
    if (attacker == NULL) return -1;
    
    strcpy(attacker->name, "Eve");
    attacker->callback = malicious_callback;
    
    // 如果此时通过user指针调用callback...
    if (user->callback != NULL) {  // user已经是悬空指针！
        user->callback();  // 执行了恶意代码！
    }
    
    free(attacker);
    return 0;
}

这个例子虽然有点刻意，但原理是真实的。在真实世界中，浏览器、数据库、操作系统内核都曾爆出过use-after-free漏洞，影响极其严重。

9.5 知识体系总览

下面这张图，是我总结的指针安全问题全景。你可以看到，所有问题都围绕着“地址有效性”这个核心。

9.6 总结与最佳实践

好了，咱们把四种指针问题都过了一遍。你可能会觉得有点多，但其实核心就一句话：永远不要相信指针里的地址是有效的。

我总结了几条铁律，你可以贴在工位上：

规则	说明
1. 声明即初始化	指针声明时立即赋值为NULL或有效地址
2. 使用前必检查	每次解引用前检查是否为NULL
3. 释放后即置空	free之后立即将指针设为NULL
4. 谁分配谁释放	明确内存所有权，避免多个指针管理同一块内存
5. 工具辅助检查	使用Valgrind、AddressSanitizer等工具检测内存问题

嗯，指针安全这块内容就到这里。记住，C语言给了你强大的能力，但也给了你足够的“机会”去犯错。小心驶得万年船。

---