裸指针与引用转换 ​

核心概念 ​

Rust 中引用(&T、&mut T)和裸指针(*const T、*mut T)之间可以互相转换。引用转换为裸指针是安全操作(不需要 unsafe),因为引用已经保证了非空、对齐、有效等条件。反过来,裸指针转换为引用是 unsafe 操作,因为编译器无法验证裸指针是否满足引用的所有要求(非空、对齐、有效、满足借用规则、生命周期正确)。这种转换机制是 Rust 安全代码和 unsafe 代码之间的桥梁,也是 FFI 和底层编程的基础。

rust
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);
}

引用转裸指针 ​

rust
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 → &Tunsafe { &*ptr }是需保证有效
*mut T → &Tunsafe { &*ptr }是需保证有效
*mut T → &mut Tunsafe { &mut *ptr }是需保证独占
*const T → *mut Tptr as *mut T否(转换本身)写入时需保证合法

裸指针转引用 ​

rust
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);
}

转换时的生命周期 ​

rust
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);
}

常见转换模式 ​

rust
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);
}

基本示例 ​

综合展示裸指针与引用转换在数据处理中的应用:

rust
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 注释说明安全性。