空指针与野指针
核心概念
空指针(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)则需要程序员自己保证安全性。
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); } // 未定义行为!
}空指针
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;
}
}野指针的产生方式
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 |
| 任意地址 | 从整数转换 | 不要从任意地址创建指针 |
防范策略
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 类型
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 实现一个简单的单链表:
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 扩容使旧指针失效、释放内存后将指针置空。