裸指针解引用
核心概念
裸指针解引用是通过 *ptr 运算符访问裸指针(*const T 或 *mut T)所指向的数据。这是 Rust 中必须在 unsafe 块中进行的操作,因为编译器无法保证裸指针指向有效的、已初始化的、正确对齐的内存。解引用 *const T 只能读取数据,解引用 *mut T 可以读取和写入数据。解引用之前,程序员必须手动确认指针满足所有安全前提:非空、正确对齐、指向已初始化的有效内存、不违反别名规则。
fn main() {
let value = 42;
let ptr: *const i32 = &value;
// 解引用裸指针需要 unsafe 块
// SAFETY: ptr 来自有效的引用,value 在当前作用域有效,
// ptr 非空、正确对齐、指向已初始化的 i32。
let read = unsafe { *ptr };
println!("读取: {}", read);
// 可变裸指针解引用
let mut mutable = 100;
let mut_ptr: *mut i32 = &mut mutable;
// SAFETY: mut_ptr 来自有效的可变引用
unsafe {
*mut_ptr = 200; // 写入
println!("写入后: {}", *mut_ptr); // 读取
}
println!("原始变量: {}", mutable);
}解引用的安全前提
fn main() {
// === 前提1:指针非空 ===
let null_ptr: *const i32 = std::ptr::null();
// unsafe { println!("{}", *null_ptr); } // 未定义行为!空指针解引用
// 正确做法:先检查
if !null_ptr.is_null() {
// SAFETY: 已确认非空(但这里不会执行)
unsafe { println!("{}", *null_ptr); }
} else {
println!("指针为空,跳过解引用");
}
// === 前提2:指针正确对齐 ===
let data: u32 = 0x12345678;
let byte_ptr = &data as *const u32 as *const u8;
// 将 byte_ptr 偏移1字节后转回 *const u32
// 此时地址不是 4 字节对齐的
let misaligned = unsafe { byte_ptr.add(1) } as *const u32;
// unsafe { println!("{}", *misaligned); } // 未定义行为!未对齐
// 正确做法:用 read_unaligned
// SAFETY: 地址虽然未对齐,但 read_unaligned 可以处理
let val = unsafe { misaligned.read_unaligned() };
println!("未对齐读取: 0x{:x}", val);
// === 前提3:指向已初始化的内存 ===
// 未初始化内存不能直接解引用
// 应使用 MaybeUninit
// === 前提4:不违反别名规则 ===
let mut x = 10;
let r = &x; // 不可变引用
let p = &mut x as *mut i32; // 这行已经有问题了
// 在 r 存活期间通过 p 写入是 UB
// unsafe { *p = 20; } // UB:r 还存活
// println!("{}", r);
println!("别名规则很重要");
}| 安全前提 | 违反后果 | 检查方式 |
|---|---|---|
| 非空 | 段错误或未定义行为 | is_null() |
| 正确对齐 | 未定义行为 | is_aligned()(nightly) |
| 已初始化 | 读到垃圾数据,UB | 使用 MaybeUninit |
| 有效内存 | 悬垂指针,UB | 人工保证生命周期 |
| 别名规则 | 未定义行为 | 人工保证无冲突访问 |
读取解引用
fn main() {
let data = [10, 20, 30, 40, 50];
let ptr = data.as_ptr();
// === 直接解引用 *ptr ===
// SAFETY: ptr 来自有效数组,指向第一个元素
let first = unsafe { *ptr };
println!("第一个: {}", first);
// === 偏移后解引用 ===
// SAFETY: ptr.add(2) 在数组范围内(索引 2 < 5)
let third = unsafe { *ptr.add(2) };
println!("第三个: {}", third);
// === 通过 read 方法读取 ===
// read() 和 *ptr 在大多数情况下等价
// 但 read() 可以用于未对齐指针(read_unaligned)
// SAFETY: ptr 有效
let val = unsafe { ptr.read() };
println!("read(): {}", val);
// === 遍历数组 ===
print!("遍历: ");
for i in 0..data.len() {
// SAFETY: i 在 0..5 范围内,ptr.add(i) 不越界
let val = unsafe { *ptr.add(i) };
print!("{} ", val);
}
println!();
// === 转换为引用后读取 ===
// SAFETY: ptr 非空、对齐、指向有效的 i32
let ref_val: &i32 = unsafe { &*ptr };
println!("转为引用: {}", ref_val);
// === 复合类型的解引用 ===
#[derive(Debug)]
struct Point { x: f64, y: f64 }
let point = Point { x: 1.5, y: 2.5 };
let point_ptr: *const Point = &point;
// SAFETY: point_ptr 来自有效引用
let p = unsafe { &*point_ptr };
println!("点: ({}, {})", p.x, p.y);
}写入解引用
fn main() {
// === 通过 *mut_ptr = val 写入 ===
let mut value = 0;
let ptr: *mut i32 = &mut value;
// SAFETY: ptr 来自有效的可变引用,指向已初始化的 i32
unsafe {
*ptr = 42;
}
println!("写入: {}", value);
// === 数组元素的写入 ===
let mut arr = [0; 5];
let ptr = arr.as_mut_ptr();
// SAFETY: 所有偏移在数组范围内
unsafe {
for i in 0..arr.len() {
*ptr.add(i) = (i + 1) as i32 * 10;
}
}
println!("数组: {:?}", arr);
// === write 方法 vs 直接赋值 ===
let mut data = String::from("旧值");
let ptr: *mut String = &mut data;
// *ptr = new_val 会 drop 旧值,然后写入新值
// SAFETY: ptr 指向有效的、已初始化的 String
unsafe {
*ptr = String::from("新值");
// 旧的 "旧值" 被正确 drop 了
}
println!("赋值后: {}", data);
// ptr.write(val) 不 drop 旧值,直接覆盖
// 适合写入未初始化内存
let layout = std::alloc::Layout::new::<String>();
// SAFETY: layout 有效
let raw = unsafe { std::alloc::alloc(layout) as *mut String };
if !raw.is_null() {
// SAFETY: raw 指向未初始化内存,用 write 不会尝试 drop 旧值
unsafe {
raw.write(String::from("写入未初始化内存"));
println!("write: {}", &*raw);
// 手动 drop 然后释放
std::ptr::drop_in_place(raw);
std::alloc::dealloc(raw as *mut u8, layout);
}
}
}| 写入方式 | 是否 drop 旧值 | 适用场景 |
|---|---|---|
*ptr = val | 是 | 已初始化的内存 |
ptr.write(val) | 否 | 未初始化的内存 |
ptr.write_unaligned(val) | 否 | 未对齐 + 未初始化 |
解引用转换为引用
fn main() {
let mut data = vec![10, 20, 30, 40, 50];
// === *const T → &T ===
let ptr: *const i32 = data.as_ptr();
// SAFETY: ptr 非空、对齐,data 在作用域内有效
let ref_val: &i32 = unsafe { &*ptr };
println!("&*ptr: {}", ref_val);
// === *mut T → &mut T ===
let mut_ptr: *mut i32 = data.as_mut_ptr();
// SAFETY: mut_ptr 有效,我们有独占访问权
let mut_ref: &mut i32 = unsafe { &mut *mut_ptr };
*mut_ref = 100;
println!("修改后: {:?}", data);
// === *const T → &[T](切片)===
let ptr = data.as_ptr();
let len = data.len();
// SAFETY: ptr 指向连续的 len 个 i32,data 在作用域内有效
let slice: &[i32] = unsafe { std::slice::from_raw_parts(ptr, len) };
println!("切片: {:?}", slice);
// === *mut T → &mut [T](可变切片)===
let mut_ptr = data.as_mut_ptr();
// SAFETY: mut_ptr 有效,len 正确,有独占访问权
let mut_slice: &mut [i32] = unsafe {
std::slice::from_raw_parts_mut(mut_ptr, len)
};
mut_slice[2] = 300;
println!("可变切片修改后: {:?}", data);
}基本示例
用裸指针解引用实现一个简单的环形缓冲区:
struct RingBuffer<T> {
data: *mut T,
capacity: usize,
head: usize, // 写入位置
tail: usize, // 读取位置
len: usize, // 当前元素数量
}
impl<T> RingBuffer<T> {
fn new(capacity: usize) -> Self {
assert!(capacity > 0, "容量必须大于0");
let layout = std::alloc::Layout::array::<T>(capacity).unwrap();
// SAFETY: capacity > 0,layout 有效
let data = unsafe { std::alloc::alloc(layout) as *mut T };
if data.is_null() {
panic!("分配失败");
}
RingBuffer { data, capacity, head: 0, tail: 0, len: 0 }
}
fn push(&mut self, value: T) -> Result<(), T> {
if self.len == self.capacity {
return Err(value); // 缓冲区满
}
// SAFETY: head < capacity,data.add(head) 在分配范围内,
// 该位置未被占用(len < capacity)
unsafe {
self.data.add(self.head).write(value);
}
self.head = (self.head + 1) % self.capacity;
self.len += 1;
Ok(())
}
fn pop(&mut self) -> Option<T> {
if self.len == 0 {
return None;
}
// SAFETY: tail < capacity,data.add(tail) 指向有效的 T
let value = unsafe { self.data.add(self.tail).read() };
self.tail = (self.tail + 1) % self.capacity;
self.len -= 1;
Some(value)
}
fn peek(&self) -> Option<&T> {
if self.len == 0 {
return None;
}
// SAFETY: tail < capacity,data.add(tail) 指向有效的 T
Some(unsafe { &*self.data.add(self.tail) })
}
fn len(&self) -> usize {
self.len
}
fn is_empty(&self) -> bool {
self.len == 0
}
fn is_full(&self) -> bool {
self.len == self.capacity
}
}
impl<T> Drop for RingBuffer<T> {
fn drop(&mut self) {
// Drop 所有剩余元素
while self.pop().is_some() {}
let layout = std::alloc::Layout::array::<T>(self.capacity).unwrap();
// SAFETY: data 和 layout 在 new 中通过 alloc 获得
unsafe {
std::alloc::dealloc(self.data as *mut u8, layout);
}
}
}
fn main() {
let mut ring = RingBuffer::new(4);
// 添加元素
println!("=== 添加元素 ===");
for i in 1..=4 {
match ring.push(i * 10) {
Ok(()) => println!(" push {} 成功, len={}", i * 10, ring.len()),
Err(v) => println!(" push {} 失败(满)", v),
}
}
// 缓冲区满
match ring.push(50) {
Ok(()) => println!(" push 50 成功"),
Err(v) => println!(" push {} 失败(满), len={}", v, ring.len()),
}
// 查看队首
println!("\n=== 查看和弹出 ===");
if let Some(val) = ring.peek() {
println!(" peek: {}", val);
}
// 弹出元素
while let Some(val) = ring.pop() {
println!(" pop: {}, 剩余: {}", val, ring.len());
}
// 环形特性测试
println!("\n=== 环形测试 ===");
let mut ring = RingBuffer::new(3);
// 先放2个,取1个,再放2个
ring.push(1).unwrap();
ring.push(2).unwrap();
println!(" pop: {:?}", ring.pop()); // 取出 1
ring.push(3).unwrap();
ring.push(4).unwrap();
// 此时缓冲区满,内容是 [2, 3, 4]
println!(" is_full: {}", ring.is_full());
while let Some(val) = ring.pop() {
print!(" {}", val);
}
println!("\n is_empty: {}", ring.is_empty());
// String 类型测试(验证 Drop)
println!("\n=== String 类型 ===");
let mut ring = RingBuffer::new(3);
ring.push(String::from("Hello")).unwrap();
ring.push(String::from("World")).unwrap();
ring.push(String::from("Rust")).unwrap();
while let Some(s) = ring.pop() {
println!(" {}", s);
}
// ring drop 时不会泄漏内存
}常见问题
问题一:解引用空指针会发生什么?
未定义行为。在大多数平台上会导致段错误(segfault)并让程序崩溃,但编译器可以假设 unsafe 代码不会解引用空指针,并据此做优化,可能导致更意外的行为。解引用前必须检查 is_null()。
*问题二:read 和解引用 ptr 有什么区别?
对于 Copy 类型,两者等价。对于非 Copy 类型,*ptr 会尝试移动值(可能导致双重释放),而 ptr.read() 会按位复制值(需要确保原位置不再被使用或 drop)。read_unaligned() 还能处理未对齐的指针。
问题三:解引用后的引用有生命周期吗?
unsafe { &*ptr } 创建的引用有一个由调用者隐含指定的生命周期。编译器会推断一个合理的生命周期,但不会验证指针指向的数据确实活得足够长。程序员必须自己保证。
问题四:可以在多线程中解引用同一个裸指针吗?
如果多个线程同时解引用 *const T(只读),且数据不被修改,通常是安全的。但如果有任何线程通过 *mut T 写入,所有并发访问(包括只读)都是数据竞争,是未定义行为。
适用场景
- 底层数据结构:链表、树、图的节点访问
- FFI:读写 C 函数返回的指针数据
- 内存映射:读取内存映射文件的内容
- 自定义集合:实现 Vec、HashMap 等底层集合
注意事项
- 解引用前必须确认:非空、对齐、已初始化、有效、不违反别名规则
*ptr = val会 drop 旧值,ptr.write(val)不会- 未对齐的指针用
read_unaligned/write_unaligned &*ptr创建引用时要确保生命周期正确- 非
Copy类型解引用要注意所有权和双重释放 - 每次解引用都要在 SAFETY 注释中说明安全性
总结
裸指针解引用(*ptr)是通过裸指针访问内存数据的操作,必须在 unsafe 块中进行。解引用前程序员必须保证指针非空、正确对齐、指向已初始化的有效内存,且不违反别名规则。解引用 *const T 只能读取,*mut T 可以读写。*ptr = val 适合已初始化内存(会 drop 旧值),ptr.write(val) 适合未初始化内存(不 drop 旧值)。&*ptr 可以将裸指针转换为引用,但生命周期由程序员负责。read_unaligned 和 write_unaligned 处理未对齐的指针。实际使用中应将解引用操作封装在安全的 API 中,对外提供带边界检查的安全接口。