裸指针与引用转换
核心概念
Rust 中引用(&T、&mut T)和裸指针(*const T、*mut T)之间可以互相转换。引用转换为裸指针是安全操作(不需要 unsafe),因为引用已经保证了非空、对齐、有效等条件。反过来,裸指针转换为引用是 unsafe 操作,因为编译器无法验证裸指针是否满足引用的所有要求(非空、对齐、有效、满足借用规则、生命周期正确)。这种转换机制是 Rust 安全代码和 unsafe 代码之间的桥梁,也是 FFI 和底层编程的基础。
fn main() {
// === 引用 → 裸指针(安全)===
let value = 42;
let ref_val: &i32 = &value;
// 隐式转换
let ptr: *const i32 = ref_val;
// 显式转换
let ptr2: *const i32 = ref_val as *const i32;
println!("引用→指针: {:p}", ptr);
// === 裸指针 → 引用(unsafe)===
// SAFETY: ptr 来自有效引用,value 在作用域内有效
let back_to_ref: &i32 = unsafe { &*ptr };
println!("指针→引用: {}", back_to_ref);
}引用转裸指针
fn main() {
// === &T → *const T ===
let x = 100;
let const_ptr: *const i32 = &x; // 隐式
let const_ptr2: *const i32 = &x as *const i32; // 显式
println!("&T → *const T: {:p}", const_ptr);
// === &mut T → *mut T ===
let mut y = 200;
let mut_ptr: *mut i32 = &mut y; // 隐式
let mut_ptr2: *mut i32 = &mut y as *mut i32; // 显式
println!("&mut T → *mut T: {:p}", mut_ptr);
// === &mut T → *const T ===
// 可变引用可以转为不可变裸指针
let mut z = 300;
let const_from_mut: *const i32 = &mut z;
println!("&mut T → *const T: {:p}", const_from_mut);
// === &[T] → *const T(切片到指针)===
let arr = [1, 2, 3, 4, 5];
let slice_ptr: *const i32 = arr.as_ptr();
println!("切片→指针: {:p}", slice_ptr);
// === &mut [T] → *mut T ===
let mut arr2 = [10, 20, 30];
let mut_slice_ptr: *mut i32 = arr2.as_mut_ptr();
println!("可变切片→指针: {:p}", mut_slice_ptr);
// === &raw const / &raw mut 语法(Rust 2024+)===
let val = 42;
let raw_ptr: *const i32 = &raw const val;
println!("&raw const: {:p}", raw_ptr);
let mut val2 = 99;
let raw_mut: *mut i32 = &raw mut val2;
println!("&raw mut: {:p}", raw_mut);
// 这些转换都不需要 unsafe
println!("所有引用→指针转换都是安全的");
}| 转换方向 | 语法 | 需要 unsafe | 说明 |
|---|---|---|---|
&T → *const T | &x as *const T 或隐式 | 否 | 引用保证有效 |
&mut T → *mut T | &mut x as *mut T 或隐式 | 否 | 引用保证有效 |
&mut T → *const T | &mut x as *const T | 否 | 丢弃可变性 |
*const T → &T | unsafe { &*ptr } | 是 | 需保证有效 |
*mut T → &T | unsafe { &*ptr } | 是 | 需保证有效 |
*mut T → &mut T | unsafe { &mut *ptr } | 是 | 需保证独占 |
*const T → *mut T | ptr as *mut T | 否(转换本身) | 写入时需保证合法 |
裸指针转引用
fn main() {
// === *const T → &T ===
let value = 42;
let ptr: *const i32 = &value;
// SAFETY: ptr 来自有效引用,value 在作用域内有效,
// ptr 非空、对齐、指向已初始化的 i32
let ref_val: &i32 = unsafe { &*ptr };
println!("*const T → &T: {}", ref_val);
// === *mut T → &mut T ===
let mut mutable = 100;
let mut_ptr: *mut i32 = &mut mutable;
// SAFETY: mut_ptr 来自有效的可变引用,
// 当前没有其他引用存在(独占访问)
let mut_ref: &mut i32 = unsafe { &mut *mut_ptr };
*mut_ref = 200;
println!("*mut T → &mut T: {}", mut_ref);
// === *mut T → &T(降级为不可变引用)===
let mut data = 42;
let ptr: *mut i32 = &mut data;
// SAFETY: ptr 有效,转为不可变引用是安全的
// (前提是没有其他 &mut 存在)
let shared_ref: &i32 = unsafe { &*ptr };
println!("*mut T → &T: {}", shared_ref);
// === 切片指针转换 ===
let arr = [10, 20, 30, 40, 50];
let ptr = arr.as_ptr();
let len = arr.len();
// SAFETY: ptr 来自有效数组,len 是数组实际长度
let slice: &[i32] = unsafe { std::slice::from_raw_parts(ptr, len) };
println!("切片: {:?}", slice);
}转换时的生命周期
fn main() {
// 裸指针没有生命周期信息
// 转为引用时,编译器会推断一个生命周期
// 但编译器不会验证这个生命周期是否正确
// === 正确的生命周期 ===
let data = vec![1, 2, 3];
let ptr = data.as_ptr();
// SAFETY: data 在下面的打印之前一直有效
let slice = unsafe { std::slice::from_raw_parts(ptr, data.len()) };
println!("正确: {:?}", slice);
// === 危险:悬垂指针转引用 ===
let ptr: *const String;
{
let temp = String::from("临时数据");
ptr = &temp as *const String;
// temp 在这里被 drop
}
// ptr 现在是悬垂指针
// unsafe { &*ptr } // 未定义行为!数据已被释放
println!("悬垂指针危险:不要解引用已释放的数据");
// === 显式标注生命周期 ===
fn ptr_to_ref<'a>(ptr: *const i32) -> &'a i32 {
// SAFETY: 调用者必须保证 ptr 在生命周期 'a 内有效
unsafe { &*ptr }
}
let value = 42;
let reference = ptr_to_ref(&value as *const i32);
println!("显式生命周期: {}", reference);
}常见转换模式
use std::slice;
// === 模式1:安全包装裸指针操作 ===
fn safe_read(data: &[i32], index: usize) -> Option<i32> {
if index >= data.len() {
return None;
}
let ptr = data.as_ptr();
// SAFETY: 已检查 index < len
Some(unsafe { *ptr.add(index) })
}
// === 模式2:从 FFI 指针创建引用 ===
/// 将 C 函数返回的指针转为安全引用
///
/// # Safety
/// ptr 必须非空、对齐、指向有效的 T,生命周期 'a 内有效
unsafe fn from_ffi_ptr<'a, T>(ptr: *const T) -> Option<&'a T> {
if ptr.is_null() {
None
} else {
Some(&*ptr)
}
}
/// 可变版本
unsafe fn from_ffi_mut<'a, T>(ptr: *mut T) -> Option<&'a mut T> {
if ptr.is_null() {
None
} else {
Some(&mut *ptr)
}
}
// === 模式3:split_at_mut 中的转换 ===
fn my_split_at_mut(slice: &mut [i32], mid: usize) -> (&mut [i32], &mut [i32]) {
let len = slice.len();
assert!(mid <= len);
let ptr = slice.as_mut_ptr();
// SAFETY: ptr 来自有效的可变切片,mid <= len,
// 两个子切片不重叠
unsafe {
(
slice::from_raw_parts_mut(ptr, mid),
slice::from_raw_parts_mut(ptr.add(mid), len - mid),
)
}
}
// === 模式4:类型双关转换 ===
fn as_bytes<T: Sized>(val: &T) -> &[u8] {
let ptr = val as *const T as *const u8;
let len = std::mem::size_of::<T>();
// SAFETY: 任何类型都可以安全地视为字节切片(只读)
unsafe { slice::from_raw_parts(ptr, len) }
}
fn main() {
let data = vec![10, 20, 30, 40, 50];
// 模式1
println!("safe_read(2): {:?}", safe_read(&data, 2));
println!("safe_read(10): {:?}", safe_read(&data, 10));
// 模式2
let value = 42;
let ptr = &value as *const i32;
// SAFETY: ptr 来自有效引用
let ref_opt = unsafe { from_ffi_ptr(ptr) };
println!("from_ffi: {:?}", ref_opt);
let null: *const i32 = std::ptr::null();
// SAFETY: 空指针,函数会返回 None
let none_opt = unsafe { from_ffi_ptr(null) };
println!("null: {:?}", none_opt);
// 模式3
let mut arr = [1, 2, 3, 4, 5];
let (left, right) = my_split_at_mut(&mut arr, 3);
left[0] = 100;
right[0] = 400;
println!("split: {:?}, {:?}", left, right);
// 模式4
let num: u32 = 0x12345678;
let bytes = as_bytes(&num);
println!("字节: {:?}", bytes);
}基本示例
综合展示裸指针与引用转换在数据处理中的应用:
use std::slice;
/// 一个简单的内存视图,支持不同类型的重新解释
struct MemoryRegion {
data: Vec<u8>,
}
impl MemoryRegion {
fn new(size: usize) -> Self {
MemoryRegion { data: vec![0u8; size] }
}
fn len(&self) -> usize {
self.data.len()
}
/// 将指定偏移处的字节解释为类型 T 的引用
fn read_as<T: Copy>(&self, offset: usize) -> Option<&T> {
let size = std::mem::size_of::<T>();
let align = std::mem::align_of::<T>();
// 边界检查
if offset + size > self.data.len() {
return None;
}
let ptr = self.data.as_ptr();
// SAFETY: ptr.add(offset) 在范围内(已检查)
let target = unsafe { ptr.add(offset) } as *const T;
// 对齐检查
if (target as usize) % align != 0 {
return None;
}
// SAFETY: 指针非空(来自 Vec)、已检查对齐和边界
Some(unsafe { &*target })
}
/// 在指定偏移处写入类型 T 的值
fn write_as<T: Copy>(&mut self, offset: usize, value: T) -> bool {
let size = std::mem::size_of::<T>();
let align = std::mem::align_of::<T>();
if offset + size > self.data.len() {
return false;
}
let ptr = self.data.as_mut_ptr();
let target = unsafe { ptr.add(offset) } as *mut T;
if (target as usize) % align != 0 {
return false;
}
// SAFETY: 已检查边界和对齐,有独占访问(&mut self)
unsafe { target.write(value); }
true
}
/// 获取指定范围的字节切片
fn bytes(&self, offset: usize, len: usize) -> Option<&[u8]> {
if offset + len > self.data.len() {
return None;
}
let ptr = self.data.as_ptr();
// SAFETY: 已检查边界
Some(unsafe { slice::from_raw_parts(ptr.add(offset), len) })
}
/// 将指定范围解释为 T 的切片
fn read_slice<T: Copy>(&self, offset: usize, count: usize) -> Option<&[T]> {
let size = std::mem::size_of::<T>() * count;
let align = std::mem::align_of::<T>();
if offset + size > self.data.len() {
return None;
}
let ptr = unsafe { self.data.as_ptr().add(offset) } as *const T;
if (ptr as usize) % align != 0 {
return None;
}
// SAFETY: 已检查边界和对齐
Some(unsafe { slice::from_raw_parts(ptr, count) })
}
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
struct Header {
magic: u32,
version: u16,
flags: u16,
size: u32,
}
fn main() {
let mut region = MemoryRegion::new(256);
// 写入一个 Header 结构
let header = Header {
magic: 0x52555354, // "RUST" 的十六进制
version: 1,
flags: 0x00FF,
size: 256,
};
println!("=== 写入结构体 ===");
assert!(region.write_as(0, header));
println!("Header 写入成功");
// 读取 Header
if let Some(h) = region.read_as::<Header>(0) {
println!("magic: 0x{:08X}", h.magic);
println!("version: {}", h.version);
println!("flags: 0x{:04X}", h.flags);
println!("size: {}", h.size);
}
// 查看原始字节
println!("\n=== 原始字节 ===");
if let Some(bytes) = region.bytes(0, 12) {
println!("前12字节: {:02X?}", bytes);
}
// 写入整数数组
println!("\n=== 写入数组 ===");
let start_offset = std::mem::size_of::<Header>();
for i in 0..10u32 {
let offset = start_offset + i as usize * 4;
region.write_as(offset, i * 100);
}
// 作为切片读取
if let Some(numbers) = region.read_slice::<u32>(start_offset, 10) {
println!("数组: {:?}", numbers);
}
// 边界检查
println!("\n=== 边界检查 ===");
println!("越界读取: {:?}", region.read_as::<u32>(254));
println!("越界写入: {}", region.write_as(260, 0u32));
// 内存总大小
println!("区域大小: {} 字节", region.len());
}常见问题
问题一:为什么引用转裸指针不需要 unsafe?
因为引用保证了非空、对齐、有效等所有安全条件。转换为裸指针只是"忘记"这些保证,本身不会产生未定义行为。危险的是之后对裸指针的操作。
问题二:从裸指针创建引用时,生命周期怎么确定?
编译器会根据上下文推断一个生命周期,但不会验证其正确性。程序员必须确保裸指针指向的数据在引用的整个生命周期内都有效。可以通过函数签名中的生命周期参数来明确标注。
*问题三:&raw const 和 as const T 有什么区别?
&raw const x 是 Rust 2024 引入的语法,它直接创建裸指针,不经过引用中间步骤。对于 packed 结构体的字段,&x.field as *const _ 可能因为创建了未对齐的引用而产生 UB,而 &raw const x.field 是安全的。
**问题四:const T 转 mut T 后写入合法吗?
取决于原始数据是否可变。如果原始数据是通过 let mut x 声明的可变变量,通过 *const T → *mut T 写入在技术上是合法的(但很脆弱)。如果原始数据是不可变的(如 let x),写入就是未定义行为。
适用场景
- FFI 桥接:将 C 函数的指针参数转为 Rust 引用
- 底层数据结构:在安全 API 和 unsafe 内部实现之间转换
- 内存映射:将原始内存解释为特定类型
- split_at_mut:借用检查器无法处理的分离借用
注意事项
- 引用→裸指针是安全的,裸指针→引用需要 unsafe
- 裸指针→引用时必须保证非空、对齐、有效、生命周期正确
&mut *ptr创建可变引用时必须保证独占访问- 悬垂指针转为引用是未定义行为
packed结构体字段应用&raw const而非as *const- 生命周期不由编译器验证,需程序员保证
总结
引用和裸指针之间的转换是 Rust 安全代码和 unsafe 代码的桥梁。引用转裸指针是安全操作(&x as *const T、&mut x as *mut T),因为引用已保证有效性。裸指针转引用需要 unsafe(&*ptr、&mut *ptr),程序员必须保证指针非空、对齐、有效、满足借用规则且生命周期正确。Rust 2024 引入的 &raw const / &raw mut 语法可以安全地为 packed 结构体字段创建裸指针。常见的转换模式包括 FFI 指针包装、split_at_mut 实现、内存重新解释等。所有裸指针→引用的转换都应有 SAFETY 注释说明安全性。