内存读写 read/write
核心概念
std::ptr::read 和 std::ptr::write 是 Rust 中通过裸指针进行内存读写的底层函数。与解引用运算符 *ptr 不同,这两个函数提供了更细粒度的控制:read 按位复制数据(不移动所有权),write 直接覆盖内存(不调用旧值的 Drop)。它们还有未对齐版本 read_unaligned / write_unaligned,可以处理地址未对齐的指针。
这些函数在实现自定义集合、内存分配器、序列化框架等底层组件时不可或缺。理解 read/write 与 *ptr 赋值的区别是避免内存泄漏和双重释放的关键。
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 的区别
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 的区别
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);
}
}未对齐读写
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);
}其他内存操作函数
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 实现一个手动管理的动态数组:
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 处理未对齐的指针。这些函数是实现自定义集合和内存管理器的基础工具。