内存读写 read/write ​

核心概念 ​

std::ptr::read 和 std::ptr::write 是 Rust 中通过裸指针进行内存读写的底层函数。与解引用运算符 *ptr 不同,这两个函数提供了更细粒度的控制:read 按位复制数据(不移动所有权),write 直接覆盖内存(不调用旧值的 Drop)。它们还有未对齐版本 read_unaligned / write_unaligned,可以处理地址未对齐的指针。

这些函数在实现自定义集合、内存分配器、序列化框架等底层组件时不可或缺。理解 read/write 与 *ptr 赋值的区别是避免内存泄漏和双重释放的关键。

rust
use std::ptr;

fn main() {
    // === ptr::read:从指针读取值 ===
    let value = 42;
    let p: *const i32 = &value;

    // SAFETY: p 来自有效引用,对齐正确
    let copied = unsafe { ptr::read(p) };
    println!("read: {}", copied);

    // === ptr::write:向指针写入值 ===
    let mut slot = 0;
    let p: *mut i32 = &mut slot;

    // SAFETY: p 来自有效的可变引用
    unsafe { ptr::write(p, 100); }
    println!("write: {}", slot);

    // === 方法形式 ===
    // 指针上也有 read/write 方法
    let data = [10, 20, 30];
    let p = data.as_ptr();
    // SAFETY: p 有效
    let val = unsafe { p.read() };
    println!("p.read(): {}", val);

    let mut arr = [0; 3];
    let p = arr.as_mut_ptr();
    // SAFETY: p 有效
    unsafe { p.write(99); }
    println!("p.write(99): {:?}", arr);
}

read 与 *ptr 的区别 ​

rust
use std::ptr;

fn main() {
    // 对于 Copy 类型,read 和 *ptr 行为基本相同
    let x = 42_i32;  // i32 是 Copy
    let p = &x as *const i32;
    // SAFETY: p 有效
    let a = unsafe { *p };        // 复制值
    let b = unsafe { ptr::read(p) };  // 按位复制
    println!("Copy 类型: *p={}, read={}", a, b);

    // 对于非 Copy 类型,区别很大
    let s = String::from("hello");
    let p = &s as *const String;

    // ptr::read 按位复制,产生一个新的 String
    // 但两个 String 共享同一块堆内存!
    // SAFETY: p 有效
    let s2 = unsafe { ptr::read(p) };
    println!("read: {}", s2);

    // 必须确保只有一个被 drop
    // 这里用 forget 防止 s2 的析构器释放共享的堆内存
    std::mem::forget(s2);
    // s 正常 drop

    println!("原始值仍有效: {}", s);
}
操作Drop 旧值移动语义适用
*ptr(读)否复制/移动已对齐、已初始化
ptr::read否按位复制已对齐、已初始化
*ptr = val(写)是覆盖已初始化的内存
ptr::write否直接写入未初始化/已初始化的内存
ptr::read_unaligned否按位复制未对齐的指针
ptr::write_unaligned否直接写入未对齐的指针

write 与 *ptr = val 的区别 ​

rust
use std::ptr;
use std::alloc::{alloc, dealloc, Layout};

fn main() {
    // === *ptr = val:会 drop 旧值 ===
    let mut s = String::from("旧值");
    let p: *mut String = &mut s;

    // SAFETY: p 有效,s 已初始化
    // *p = new_val 会先 drop "旧值",再写入 "新值"
    unsafe { *p = String::from("新值"); }
    println!("*ptr 赋值: {}", s);
    // "旧值" 的堆内存已正确释放

    // === ptr::write:不 drop 旧值 ===
    // 适合写入未初始化的内存
    let layout = Layout::new::<String>();
    // SAFETY: layout 有效
    let raw = unsafe { alloc(layout) as *mut String };
    assert!(!raw.is_null());

    // raw 指向未初始化内存
    // 不能用 *raw = val(会尝试 drop 未初始化的数据 → UB)
    // 必须用 ptr::write
    // SAFETY: raw 非空,对齐正确
    unsafe {
        ptr::write(raw, String::from("写入未初始化内存"));
        println!("write: {}", &*raw);

        // 手动 drop 然后释放
        ptr::drop_in_place(raw);
        dealloc(raw as *mut u8, layout);
    }

    // === 已初始化内存用 write 会泄漏 ===
    let mut data = String::from("会被泄漏");
    let p: *mut String = &mut data;

    // ptr::write 不 drop 旧值
    // 如果 p 指向已初始化的 String,旧值的堆内存会泄漏
    // SAFETY: p 有效,但旧值会泄漏
    unsafe {
        // 先手动 drop 旧值
        ptr::drop_in_place(p);
        // 然后 write 新值
        ptr::write(p, String::from("正确方式"));
        println!("先 drop 再 write: {}", &*p);
    }
}

未对齐读写 ​

rust
use std::ptr;

fn main() {
    // 某些场景下指针可能未对齐
    // 比如 packed 结构体的字段、网络数据包解析

    // 构造一个未对齐的 u32 指针
    let buffer = [0u8, 0x78, 0x56, 0x34, 0x12, 0];
    let unaligned_ptr = &buffer[1] as *const u8 as *const u32;

    // 检查对齐
    let is_aligned = (unaligned_ptr as usize) % std::mem::align_of::<u32>() == 0;
    println!("指针对齐: {}", is_aligned);

    // read_unaligned 可以安全地从未对齐地址读取
    // SAFETY: 指针指向足够大的有效内存区域
    let val = unsafe { ptr::read_unaligned(unaligned_ptr) };
    println!("read_unaligned: 0x{:08X}", val);

    // write_unaligned 可以安全地写入未对齐地址
    let mut buffer2 = [0u8; 6];
    let unaligned_ptr2 = &mut buffer2[1] as *mut u8 as *mut u32;
    // SAFETY: 足够的空间
    unsafe { ptr::write_unaligned(unaligned_ptr2, 0xDEADBEEF_u32); }
    println!("write_unaligned 后: {:02X?}", buffer2);

    // #[repr(packed)] 结构体的字段可能未对齐
    #[repr(C, packed)]
    struct Packed {
        a: u8,
        b: u32,  // 偏移1,未对齐!
        c: u16,  // 偏移5,未对齐!
    }

    let p = Packed { a: 1, b: 0x12345678, c: 0xABCD };

    // 不能直接取引用(可能产生未对齐引用)
    // let b_ref = &p.b;  // 可能 UB

    // 用 read_unaligned 安全读取
    let b_ptr = &raw const p.b;
    // SAFETY: b_ptr 指向有效数据
    let b_val = unsafe { ptr::read_unaligned(b_ptr) };
    println!("\npacked 字段 b: 0x{:08X}", b_val);

    let c_ptr = &raw const p.c;
    let c_val = unsafe { ptr::read_unaligned(c_ptr) };
    println!("packed 字段 c: 0x{:04X}", c_val);
}

其他内存操作函数 ​

rust
use std::ptr;

fn main() {
    // === ptr::copy:可重叠的内存复制(类似 C 的 memmove)===
    let mut data = [1, 2, 3, 4, 5];
    // SAFETY: 源和目标都在 data 范围内
    unsafe {
        // 将 [1,2,3] 复制到 [3,4,5] 的位置(有重叠)
        ptr::copy(data.as_ptr(), data.as_mut_ptr().add(2), 3);
    }
    println!("copy(重叠): {:?}", data);  // [1, 2, 1, 2, 3]

    // === ptr::copy_nonoverlapping:不可重叠的内存复制(类似 C 的 memcpy)===
    let src = [10, 20, 30];
    let mut dst = [0; 3];
    // SAFETY: src 和 dst 不重叠
    unsafe {
        ptr::copy_nonoverlapping(src.as_ptr(), dst.as_mut_ptr(), 3);
    }
    println!("copy_nonoverlapping: {:?}", dst);

    // === ptr::swap:交换两个指针指向的值 ===
    let mut a = 100;
    let mut b = 200;
    // SAFETY: 两个指针有效,不重叠
    unsafe {
        ptr::swap(&mut a, &mut b);
    }
    println!("swap: a={}, b={}", a, b);

    // === ptr::replace:替换并返回旧值 ===
    let mut val = String::from("旧");
    let old = unsafe { ptr::replace(&mut val, String::from("新")) };
    println!("replace: old={}, new={}", old, val);

    // === ptr::drop_in_place:就地调用析构器 ===
    let mut s = String::from("将被 drop");
    let p: *mut String = &mut s;
    // SAFETY: p 有效,s 之后不再使用
    unsafe {
        ptr::drop_in_place(p);
    }
    // s 已被 drop,但栈上的内存还在
    // 不能再使用 s(已经是未初始化状态)
    std::mem::forget(s);  // 防止二次 drop

    // === ptr::write_bytes:填充字节(类似 C 的 memset)===
    let mut arr = [0u32; 4];
    // SAFETY: arr 有效,4 个 u32
    unsafe {
        ptr::write_bytes(arr.as_mut_ptr(), 0xFF, 4);
    }
    println!("write_bytes: {:08X?}", arr);
}
函数功能允许重叠Drop 旧值
ptr::read读取值-否
ptr::write写入值-否
ptr::copy复制内存是否
ptr::copy_nonoverlapping复制内存否(更快)否
ptr::swap交换两个位置的值否否
ptr::replace替换并返回旧值-否
ptr::drop_in_place调用析构器-是
ptr::write_bytes填充字节-否

基本示例 ​

用 read/write 实现一个手动管理的动态数组:

rust
use std::alloc::{alloc, dealloc, realloc, Layout};
use std::ptr;

struct RawVec<T> {
    ptr: *mut T,
    len: usize,
    capacity: usize,
}

impl<T> RawVec<T> {
    fn new() -> Self {
        RawVec {
            ptr: ptr::null_mut(),
            len: 0,
            capacity: 0,
        }
    }

    fn with_capacity(capacity: usize) -> Self {
        if capacity == 0 {
            return Self::new();
        }

        let layout = Layout::array::<T>(capacity).unwrap();
        // SAFETY: capacity > 0,layout 有效
        let ptr = unsafe { alloc(layout) as *mut T };
        if ptr.is_null() {
            panic!("分配失败");
        }

        RawVec { ptr, len: 0, capacity }
    }

    fn push(&mut self, value: T) {
        if self.len == self.capacity {
            self.grow();
        }

        // SAFETY: len < capacity,ptr.add(len) 在分配范围内,
        // 该位置未初始化
        unsafe {
            ptr::write(self.ptr.add(self.len), value);
        }
        self.len += 1;
    }

    fn pop(&mut self) -> Option<T> {
        if self.len == 0 {
            return None;
        }

        self.len -= 1;
        // SAFETY: len 之前 > 0,ptr.add(len) 指向有效的 T
        Some(unsafe { ptr::read(self.ptr.add(self.len)) })
    }

    fn get(&self, index: usize) -> Option<&T> {
        if index >= self.len {
            return None;
        }
        // SAFETY: index < len,ptr.add(index) 有效
        Some(unsafe { &*self.ptr.add(index) })
    }

    fn set(&mut self, index: usize, value: T) -> bool {
        if index >= self.len {
            return false;
        }
        // SAFETY: index < len,旧值需要先 drop
        unsafe {
            ptr::drop_in_place(self.ptr.add(index));
            ptr::write(self.ptr.add(index), value);
        }
        true
    }

    fn insert(&mut self, index: usize, value: T) {
        assert!(index <= self.len, "索引越界");

        if self.len == self.capacity {
            self.grow();
        }

        // 将 [index..len] 向后移动一位
        if index < self.len {
            // SAFETY: 移动的元素在分配范围内
            unsafe {
                ptr::copy(
                    self.ptr.add(index),
                    self.ptr.add(index + 1),
                    self.len - index,
                );
            }
        }

        // SAFETY: index 位置现在是"空洞",可以写入
        unsafe { ptr::write(self.ptr.add(index), value); }
        self.len += 1;
    }

    fn remove(&mut self, index: usize) -> T {
        assert!(index < self.len, "索引越界");

        // 读出要移除的元素
        // SAFETY: index < len
        let value = unsafe { ptr::read(self.ptr.add(index)) };

        // 将 [index+1..len] 向前移动一位
        if index < self.len - 1 {
            // SAFETY: 移动的元素在分配范围内
            unsafe {
                ptr::copy(
                    self.ptr.add(index + 1),
                    self.ptr.add(index),
                    self.len - index - 1,
                );
            }
        }

        self.len -= 1;
        value
    }

    fn len(&self) -> usize {
        self.len
    }

    fn capacity(&self) -> usize {
        self.capacity
    }

    fn grow(&mut self) {
        let new_cap = if self.capacity == 0 { 4 } else { self.capacity * 2 };
        let new_layout = Layout::array::<T>(new_cap).unwrap();

        let new_ptr = if self.ptr.is_null() {
            // SAFETY: new_layout 有效
            unsafe { alloc(new_layout) as *mut T }
        } else {
            let old_layout = Layout::array::<T>(self.capacity).unwrap();
            // SAFETY: ptr 和 old_layout 匹配,new_layout 有效
            unsafe {
                realloc(self.ptr as *mut u8, old_layout, new_layout.size()) as *mut T
            }
        };

        if new_ptr.is_null() {
            panic!("扩容分配失败");
        }

        self.ptr = new_ptr;
        self.capacity = new_cap;
    }
}

impl<T> Drop for RawVec<T> {
    fn drop(&mut self) {
        if !self.ptr.is_null() {
            // Drop 所有元素
            for i in 0..self.len {
                // SAFETY: 每个元素有效
                unsafe { ptr::drop_in_place(self.ptr.add(i)); }
            }

            // 释放内存
            let layout = Layout::array::<T>(self.capacity).unwrap();
            // SAFETY: ptr 和 layout 匹配
            unsafe { dealloc(self.ptr as *mut u8, layout); }
        }
    }
}

impl<T: std::fmt::Debug> std::fmt::Debug for RawVec<T> {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        write!(f, "[")?;
        for i in 0..self.len {
            if i > 0 { write!(f, ", ")?; }
            // SAFETY: i < len
            let val = unsafe { &*self.ptr.add(i) };
            write!(f, "{:?}", val)?;
        }
        write!(f, "]")
    }
}

fn main() {
    println!("=== RawVec<i32> ===");
    let mut v = RawVec::with_capacity(4);
    for i in 0..6 {
        v.push(i * 10);
        println!("push {}: len={}, cap={}", i * 10, v.len(), v.capacity());
    }
    println!("内容: {:?}", v);

    // pop
    println!("\n=== pop ===");
    while let Some(val) = v.pop() {
        println!("pop: {}", val);
    }

    // insert / remove
    println!("\n=== insert / remove ===");
    let mut v = RawVec::new();
    v.push(10);
    v.push(30);
    v.push(40);
    println!("初始: {:?}", v);

    v.insert(1, 20);  // 在索引 1 插入 20
    println!("insert(1, 20): {:?}", v);

    let removed = v.remove(2);  // 移除索引 2(值 30)
    println!("remove(2)={}: {:?}", removed, v);

    // get / set
    println!("\n=== get / set ===");
    println!("get(0): {:?}", v.get(0));
    v.set(0, 100);
    println!("set(0, 100): {:?}", v);

    // String 类型(测试 Drop)
    println!("\n=== RawVec<String> ===");
    let mut sv = RawVec::new();
    sv.push(String::from("Hello"));
    sv.push(String::from("World"));
    sv.push(String::from("Rust"));
    println!("{:?}", sv);

    let removed = sv.remove(1);
    println!("remove(1)={}: {:?}", removed, sv);
    // sv drop 时正确释放所有 String
}

常见问题 ​

*问题一:什么时候用 write 而不是 ptr = val?

当目标内存未初始化时用 write。*ptr = val 会先 drop 旧值,对未初始化内存这么做是 UB。write 直接覆盖内存,不触发旧值的 Drop。

问题二:read 后原来的值还能用吗?

对于 Copy 类型可以。对于非 Copy 类型,read 产生了一个按位复制的副本,原值和副本共享底层资源(如堆内存),只能 drop 其中一个,否则会双重释放。

问题三:copy 和 copy_nonoverlapping 选哪个?

如果确定源和目标不重叠,用 copy_nonoverlapping,它更快。如果可能重叠(如同一数组内的移动),必须用 copy。用错会导致 UB。

问题四:drop_in_place 和直接 drop 有什么区别?

drop(val) 接收值的所有权并 drop 它。drop_in_place(ptr) 就地调用析构器但不释放内存——内存仍然存在,只是里面的值被"析构"了(如释放堆上的数据)。用于手动管理内存时需要在 dealloc 前调用 drop_in_place。

适用场景 ​

  • 自定义集合:实现 Vec、HashMap 等底层容器
  • 内存分配器:管理未初始化的内存块
  • 序列化:将结构体按字节读写
  • FFI:读写 C 库管理的内存

注意事项 ​

  • 未初始化内存只能用 write,不能用 *ptr = val
  • read 对非 Copy 类型会产生共享底层资源的副本
  • copy 允许重叠,copy_nonoverlapping 不允许
  • 已初始化内存用 write 前应先 drop_in_place
  • 释放内存前必须 drop_in_place 所有活跃元素
  • 未对齐指针用 read_unaligned / write_unaligned

总结 ​

ptr::read 从指针按位复制值(不移动所有权),ptr::write 向指针直接写入值(不 drop 旧值)。write 适合未初始化内存,*ptr = val 适合已初始化内存(会 drop 旧值)。已初始化内存用 write 覆盖前应先 drop_in_place 防止泄漏。copy 处理可重叠的内存复制,copy_nonoverlapping 处理不重叠的(更快)。swap 交换两个位置的值,replace 替换并返回旧值。drop_in_place 就地调用析构器但不释放内存。read_unaligned / write_unaligned 处理未对齐的指针。这些函数是实现自定义集合和内存管理器的基础工具。