空指针与野指针 ​

核心概念 ​

空指针(null pointer)是一个特殊的指针值,表示"不指向任何有效数据"。在 Rust 中,std::ptr::null() 创建 *const T 的空指针,std::ptr::null_mut() 创建 *mut T 的空指针。空指针的地址值为 0。解引用空指针是未定义行为。

野指针(wild pointer / dangling pointer)是指向无效内存的指针——它曾经指向有效数据,但那块内存已经被释放、超出作用域或者被重新分配了。野指针比空指针更危险,因为它看起来像一个正常的非空指针,is_null() 检查不会发现它。解引用野指针同样是未定义行为,可能读到垃圾数据、修改不相关的内存、甚至导致安全漏洞。

Rust 的引用系统(&T、&mut T)通过借用检查器在编译时杜绝了空指针和野指针的问题。裸指针(*const T、*mut T)则需要程序员自己保证安全性。

rust
fn main() {
    // === 空指针 ===
    let null_const: *const i32 = std::ptr::null();
    let null_mut: *mut i32 = std::ptr::null_mut();

    println!("空指针地址: {:p}", null_const);    // 0x0
    println!("是否为空: {}", null_const.is_null());  // true
    println!("可变空指针: {:p}", null_mut);

    // 解引用空指针是 UB
    // unsafe { println!("{}", *null_const); }  // 未定义行为!

    // === 野指针(悬垂指针)===
    let wild_ptr: *const String;
    {
        let temp = String::from("临时数据");
        wild_ptr = &temp as *const String;
        println!("有效时: {:p}", wild_ptr);
        // temp 在此处被 drop,内存被释放
    }
    // wild_ptr 现在是野指针
    println!("野指针地址: {:p} (数据已无效!)", wild_ptr);
    println!("is_null: {} (野指针不是空指针!)", wild_ptr.is_null());
    // unsafe { println!("{}", &*wild_ptr); }  // 未定义行为!
}

空指针 ​

rust
use std::ptr;

fn main() {
    // === 创建空指针 ===
    let null_i32: *const i32 = ptr::null();
    let null_str: *const str = ptr::null();
    let null_mut_f64: *mut f64 = ptr::null_mut();

    // === 检查空指针 ===
    assert!(null_i32.is_null());
    assert!(null_mut_f64.is_null());

    // === 空指针的用途 ===
    // 1. 表示"无数据"(类似 C 中的 NULL)
    // 2. 初始化尚未赋值的指针字段
    // 3. FFI 中表示可选参数

    // 使用空指针作为"无数据"标记
    struct Node {
        value: i32,
        next: *mut Node,  // 空指针表示链表末尾
    }

    let mut node = Node { value: 42, next: ptr::null_mut() };
    println!("节点值: {}", node.value);
    println!("下一个节点: {:p} (空=末尾)", node.next);

    // 添加下一个节点
    let mut next_node = Node { value: 100, next: ptr::null_mut() };
    node.next = &mut next_node;
    println!("链接后: {:p} (非空)", node.next);

    // 遍历链表
    let mut current: *const Node = &node;
    while !current.is_null() {
        // SAFETY: current 非空,指向有效的 Node
        let n = unsafe { &*current };
        println!("  遍历: {}", n.value);
        current = n.next;
    }
}

野指针的产生方式 ​

rust
fn main() {
    // === 方式1:变量离开作用域 ===
    let ptr: *const i32;
    {
        let local = 42;
        ptr = &local as *const i32;
    }
    // local 已销毁,ptr 是野指针
    println!("方式1 - 栈变量销毁: {:p} (野指针)", ptr);

    // === 方式2:堆内存被释放 ===
    let ptr: *const String;
    {
        let boxed = Box::new(String::from("堆数据"));
        ptr = &*boxed as *const String;
    }
    // Box 被 drop,堆内存被释放
    println!("方式2 - 堆内存释放: {:p} (野指针)", ptr);

    // === 方式3:Vec 重新分配 ===
    let mut v = vec![1, 2, 3];
    let ptr = v.as_ptr();
    println!("方式3 - 重分配前: {:p}", ptr);

    // push 可能触发重新分配,旧指针变成野指针
    for i in 0..100 {
        v.push(i);
    }
    let new_ptr = v.as_ptr();
    if ptr != new_ptr {
        println!("  Vec 重新分配了!旧指针 {:p} 是野指针", ptr);
        println!("  新指针: {:p}", new_ptr);
    }

    // === 方式4:手动释放后使用 ===
    let boxed = Box::new(42);
    let ptr = Box::into_raw(boxed);
    // SAFETY: ptr 来自 Box::into_raw
    unsafe { drop(Box::from_raw(ptr)); }
    // 内存已释放,ptr 是野指针
    println!("方式4 - 手动释放: {:p} (野指针)", ptr);

    // === 方式5:从任意地址创建 ===
    let arbitrary: *const i32 = 0x12345678 as *const i32;
    println!("方式5 - 任意地址: {:p} (几乎一定是野指针)", arbitrary);
}
产生方式原因防范措施
变量离开作用域栈上数据销毁确保指针不超出变量生命周期
堆内存释放Box/Vec drop用 Box::into_raw 管理所有权
Vec 重新分配push 导致扩容操作完成后重新获取指针
手动释放后使用dealloc 后继续使用释放后立即置为 null
任意地址从整数转换不要从任意地址创建指针

防范策略 ​

rust
use std::ptr;

// === 策略1:使用 Option 代替空指针 ===
// Rust 的引用不能为空,Option<&T> 是安全的替代方案
fn find_item(data: &[i32], target: i32) -> Option<&i32> {
    data.iter().find(|&&x| x == target)
}

// === 策略2:空指针检查封装 ===
fn safe_deref(ptr: *const i32) -> Option<i32> {
    if ptr.is_null() {
        None
    } else {
        // SAFETY: 已确认非空
        // 注意:非空不等于有效,调用者仍需保证指针有效
        Some(unsafe { *ptr })
    }
}

// === 策略3:释放后置空 ===
struct ManagedPtr {
    ptr: *mut i32,
}

impl ManagedPtr {
    fn new(value: i32) -> Self {
        let ptr = Box::into_raw(Box::new(value));
        ManagedPtr { ptr }
    }

    fn get(&self) -> Option<i32> {
        if self.ptr.is_null() {
            None
        } else {
            // SAFETY: 非空时指针有效(由我们的管理逻辑保证)
            Some(unsafe { *self.ptr })
        }
    }

    fn release(&mut self) {
        if !self.ptr.is_null() {
            // SAFETY: ptr 来自 Box::into_raw,且非空
            unsafe { drop(Box::from_raw(self.ptr)); }
            self.ptr = ptr::null_mut();  // 释放后置空
        }
    }
}

impl Drop for ManagedPtr {
    fn drop(&mut self) {
        self.release();
    }
}

// === 策略4:NonNull 代替裸指针 ===
use std::ptr::NonNull;

struct SafeBox<T> {
    ptr: NonNull<T>,  // 保证非空
}

impl<T> SafeBox<T> {
    fn new(value: T) -> Self {
        let ptr = Box::into_raw(Box::new(value));
        // SAFETY: Box::into_raw 返回的指针非空
        SafeBox { ptr: unsafe { NonNull::new_unchecked(ptr) } }
    }

    fn get(&self) -> &T {
        // SAFETY: NonNull 保证非空,我们保证指针有效
        unsafe { self.ptr.as_ref() }
    }
}

impl<T> Drop for SafeBox<T> {
    fn drop(&mut self) {
        // SAFETY: ptr 来自 Box::into_raw
        unsafe { drop(Box::from_raw(self.ptr.as_ptr())); }
    }
}

fn main() {
    // 策略1
    let data = [1, 2, 3, 4, 5];
    println!("查找3: {:?}", find_item(&data, 3));
    println!("查找9: {:?}", find_item(&data, 9));

    // 策略2
    let x = 42;
    println!("safe_deref: {:?}", safe_deref(&x));
    println!("safe_deref null: {:?}", safe_deref(ptr::null()));

    // 策略3
    let mut managed = ManagedPtr::new(100);
    println!("释放前: {:?}", managed.get());
    managed.release();
    println!("释放后: {:?}", managed.get());
    // 再次释放不会出问题(已置空)
    managed.release();

    // 策略4
    let safe_box = SafeBox::new(String::from("安全的非空指针"));
    println!("NonNull: {}", safe_box.get());
}

NonNull 类型 ​

rust
use std::ptr::NonNull;

fn main() {
    // NonNull<T> 是一个保证非空的裸指针包装
    // 它占用和 *mut T 相同的空间
    // Option<NonNull<T>> 与 *mut T 大小相同(空指针优化)

    // === 创建 NonNull ===
    let mut value = 42;

    // 从可变引用创建(安全)
    let nn = NonNull::from(&mut value);
    println!("NonNull: {:p}", nn);

    // 从裸指针创建(需要确保非空)
    let ptr = &mut value as *mut i32;
    let nn2 = NonNull::new(ptr);  // 返回 Option<NonNull<T>>
    println!("from *mut: {:?}", nn2.is_some());

    // 从空指针创建会返回 None
    let nn_null = NonNull::<i32>::new(std::ptr::null_mut());
    println!("from null: {:?}", nn_null.is_none());

    // === 使用 NonNull ===
    // SAFETY: nn 来自有效的引用
    let val = unsafe { *nn.as_ptr() };
    println!("读取: {}", val);

    // 转为引用
    // SAFETY: nn 来自有效引用,value 在作用域内
    let ref_val: &i32 = unsafe { nn.as_ref() };
    println!("引用: {}", ref_val);

    // === 空指针优化 ===
    println!("\n大小比较:");
    println!("  *mut i32:              {} 字节", std::mem::size_of::<*mut i32>());
    println!("  NonNull<i32>:          {} 字节", std::mem::size_of::<NonNull<i32>>());
    println!("  Option<NonNull<i32>>:  {} 字节", std::mem::size_of::<Option<NonNull<i32>>>());
    // Option<NonNull<T>> 利用空指针优化,和 *mut T 一样大
}

基本示例 ​

用空指针和 NonNull 实现一个简单的单链表:

rust
use std::ptr::NonNull;
use std::fmt;

// 链表节点
struct Node<T> {
    value: T,
    next: Option<NonNull<Node<T>>>,  // 用 Option<NonNull> 代替裸指针
}

// 单链表
struct LinkedList<T> {
    head: Option<NonNull<Node<T>>>,
    len: usize,
}

impl<T> LinkedList<T> {
    fn new() -> Self {
        LinkedList { head: None, len: 0 }
    }

    // 在头部插入
    fn push_front(&mut self, value: T) {
        let node = Box::new(Node {
            value,
            next: self.head,  // 新节点指向当前头部
        });

        let ptr = NonNull::from(Box::leak(node));
        self.head = Some(ptr);
        self.len += 1;
    }

    // 从头部弹出
    fn pop_front(&mut self) -> Option<T> {
        self.head.map(|node_ptr| {
            // SAFETY: node_ptr 来自 Box::leak,有效且非空
            let node = unsafe { Box::from_raw(node_ptr.as_ptr()) };
            self.head = node.next;
            self.len -= 1;
            node.value
        })
    }

    // 查看头部元素
    fn peek(&self) -> Option<&T> {
        self.head.map(|node_ptr| {
            // SAFETY: node_ptr 有效
            unsafe { &node_ptr.as_ref().value }
        })
    }

    fn len(&self) -> usize {
        self.len
    }

    fn is_empty(&self) -> bool {
        self.len == 0
    }

    // 迭代器
    fn iter(&self) -> LinkedListIter<T> {
        LinkedListIter { current: self.head }
    }
}

struct LinkedListIter<T> {
    current: Option<NonNull<Node<T>>>,
}

impl<'a, T> Iterator for LinkedListIter<T> {
    type Item = &'a T;

    fn next(&mut self) -> Option<Self::Item> {
        self.current.map(|node_ptr| {
            // SAFETY: node_ptr 有效
            let node = unsafe { node_ptr.as_ref() };
            self.current = node.next;
            &node.value
        })
    }
}

impl<T> Drop for LinkedList<T> {
    fn drop(&mut self) {
        // 释放所有节点
        while self.pop_front().is_some() {}
    }
}

impl<T: fmt::Display> fmt::Display for LinkedList<T> {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "[")?;
        let mut first = true;
        for val in self.iter() {
            if !first { write!(f, " → ")?; }
            write!(f, "{}", val)?;
            first = false;
        }
        write!(f, "]")
    }
}

fn main() {
    let mut list = LinkedList::new();

    // 添加元素
    println!("=== 构建链表 ===");
    for i in (1..=5).rev() {
        list.push_front(i);
    }
    println!("链表: {}", list);
    println!("长度: {}", list.len());

    // 查看头部
    println!("\n=== 查看 ===");
    println!("头部: {:?}", list.peek());

    // 迭代
    println!("\n=== 迭代 ===");
    for val in list.iter() {
        print!("{} ", val);
    }
    println!();

    // 弹出
    println!("\n=== 弹出 ===");
    while let Some(val) = list.pop_front() {
        println!("弹出: {}, 剩余: {}", val, list.len());
    }
    println!("空: {}", list.is_empty());

    // String 类型验证 Drop
    println!("\n=== String 链表 ===");
    let mut str_list = LinkedList::new();
    str_list.push_front(String::from("World"));
    str_list.push_front(String::from("Hello"));
    println!("{}", str_list);
    // str_list drop 时正确释放所有 String
}

常见问题 ​

问题一:Rust 的引用能为空吗?

不能。&T 和 &mut T 保证非空,编译器在此基础上做优化。如果需要表示"可能为空",用 Option<&T>,编译器会利用空指针优化使其和裸指针一样大。

问题二:is_null() 能检测野指针吗?

不能。野指针的地址值通常不是 0(它曾经指向有效内存),is_null() 无法区分野指针和有效指针。检测野指针只能靠程序员自己管理指针的生命周期。

问题三:NonNull 能防止野指针吗?

不能。NonNull 只保证指针值不为 0,不保证指针指向有效内存。它防止了空指针的问题,但野指针仍然需要程序员自己避免。

问题四:C 的 NULL 和 Rust 的 null() 一样吗?

在绝大多数平台上是一样的(地址值都是 0)。在 FFI 中可以互换使用。Rust 的 std::ptr::null() 对应 C 的 NULL 或 (void*)0。

适用场景 ​

  • FFI:C 函数经常用 NULL 表示失败或无数据
  • 链表/树:用空指针表示末尾或空节点
  • 可选指针字段:Option<NonNull<T>> 代替可空裸指针
  • 底层内存管理:分配器中标记空闲/已释放的内存块

注意事项 ​

  • 解引用空指针和野指针都是未定义行为
  • is_null() 只能检测空指针,无法检测野指针
  • 优先使用 Option<&T> 代替可空裸指针
  • 优先使用 NonNull<T> 代替 *mut T
  • 释放内存后立即将指针置为 null
  • Vec 扩容后旧指针变成野指针
  • Rust 引用不能为空,编译器会据此优化

总结 ​

空指针是地址值为 0 的特殊指针,用 std::ptr::null() / null_mut() 创建,通过 is_null() 检查。野指针是指向已释放或无效内存的指针,比空指针更危险,因为 is_null() 检查不到。解引用空指针和野指针都是未定义行为。Rust 的引用系统(&T、&mut T)从编译时就杜绝了这两种问题。在需要裸指针的场景中,应优先使用 NonNull<T>(保证非空)和 Option<NonNull<T>>(利用空指针优化)。防范野指针的关键是正确管理指针的生命周期:不使用超出作用域的指针、注意 Vec 扩容使旧指针失效、释放内存后将指针置空。