裸指针解引用 ​

核心概念 ​

裸指针解引用是通过 *ptr 运算符访问裸指针(*const T 或 *mut T)所指向的数据。这是 Rust 中必须在 unsafe 块中进行的操作,因为编译器无法保证裸指针指向有效的、已初始化的、正确对齐的内存。解引用 *const T 只能读取数据,解引用 *mut T 可以读取和写入数据。解引用之前,程序员必须手动确认指针满足所有安全前提:非空、正确对齐、指向已初始化的有效内存、不违反别名规则。

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

解引用的安全前提 ​

rust
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人工保证生命周期
别名规则未定义行为人工保证无冲突访问

读取解引用 ​

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

写入解引用 ​

rust
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)否未对齐 + 未初始化

解引用转换为引用 ​

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

基本示例 ​

用裸指针解引用实现一个简单的环形缓冲区:

rust
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 中,对外提供带边界检查的安全接口。