裸指针 *mut T
核心概念
*mut T 是 Rust 中的可变裸指针,存储一个内存地址并允许通过该地址读取和写入类型 T 的数据。与 *const T 相比,*mut T 在语义上表示"可以修改指向的数据"。和所有裸指针一样,*mut T 不受借用检查器约束,没有生命周期限制,可以为空或悬垂。创建 *mut T 是安全操作,但通过它读写数据需要在 unsafe 块中进行。*mut T 在 FFI、底层数据结构实现和需要可变访问的低级操作中广泛使用。
fn main() {
let mut value = 42;
// 从可变引用创建 *mut T
let ptr: *mut i32 = &mut value as *mut i32;
// 也可以用 &raw mut 语法(Rust 2024+)
let ptr2: *mut i32 = &raw mut value;
// 读取和写入都需要 unsafe
// SAFETY: ptr 来自有效的可变引用,value 在当前作用域有效
unsafe {
println!("读取: {}", *ptr);
*ptr = 100; // 通过裸指针修改值
println!("修改后: {}", *ptr);
}
// value 也被修改了(因为 ptr 指向 value)
println!("value: {}", value);
// 空的可变裸指针
let null_ptr: *mut i32 = std::ptr::null_mut();
println!("空指针: {:p}, 是否为空: {}", null_ptr, null_ptr.is_null());
}*mut T 的创建方式
fn main() {
// === 从可变引用转换 ===
let mut x = 10;
let ptr1: *mut i32 = &mut x; // 隐式转换
let ptr2: *mut i32 = &mut x as *mut i32; // 显式转换
// === &raw mut 语法 ===
let ptr3: *mut i32 = &raw mut x;
// === 空指针 ===
let null: *mut i32 = std::ptr::null_mut();
// === 从 Box 获取 ===
let boxed = Box::new(42);
let ptr4: *mut i32 = Box::into_raw(boxed);
// 必须手动释放
// SAFETY: ptr4 来自 Box::into_raw
let _ = unsafe { Box::from_raw(ptr4) };
// === 从 Vec 获取 ===
let mut v = vec![1, 2, 3];
let ptr5: *mut i32 = v.as_mut_ptr();
// === 内存分配 ===
let layout = std::alloc::Layout::new::<i32>();
// SAFETY: layout 大小 > 0
let ptr6: *mut u8 = unsafe { std::alloc::alloc(layout) };
if !ptr6.is_null() {
let ptr6 = ptr6 as *mut i32;
// SAFETY: ptr6 来自 alloc,大小和对齐匹配 i32
unsafe {
*ptr6 = 999;
println!("alloc 分配: {}", *ptr6);
std::alloc::dealloc(ptr6 as *mut u8, layout);
}
}
// === 从 *const T 转换(cast)===
let const_ptr: *const i32 = &x as *const i32;
let mut_ptr: *mut i32 = const_ptr as *mut i32;
// 注意:如果原始数据是不可变的,通过 mut_ptr 写入是 UB
// SAFETY: ptr1, ptr3, ptr5 都来自有效的可变数据
unsafe {
println!("ptr1: {}", *ptr1);
println!("ptr3: {}", *ptr3);
println!("ptr5: {}", *ptr5);
}
}*mut T 的方法
fn main() {
let mut data = [10, 20, 30, 40, 50];
let ptr = data.as_mut_ptr();
// === 读写操作 ===
// SAFETY: 所有操作在数组范围内,ptr 来自有效的可变数组
unsafe {
// write:写入值(不调用旧值的 Drop)
ptr.write(100);
println!("write 后: {:?}", data);
// read:读取值(不移动所有权)
let val = ptr.read();
println!("read: {}", val);
// replace:替换值并返回旧值
let old = ptr.replace(200);
println!("replace: 旧值={}, 新值={}", old, *ptr);
// add / sub:指针偏移
let third = ptr.add(2);
*third = 300;
println!("修改第三个: {:?}", data);
// swap:交换两个指针指向的值
let first = ptr;
let last = ptr.add(4);
std::ptr::swap(first, last);
println!("交换后: {:?}", data);
}
// === 安全方法(不需要 unsafe)===
println!("is_null: {}", ptr.is_null());
println!("地址: {:p}", ptr);
// cast:类型转换
let byte_ptr: *mut u8 = ptr.cast::<u8>();
println!("cast 后: {:p}", byte_ptr);
// wrapping_add:允许溢出的偏移
let wrapped = ptr.wrapping_add(100);
println!("wrapping_add: {:p}", wrapped);
}| 方法 | 说明 | 需要 unsafe |
|---|---|---|
write(val) | 写入值(不 drop 旧值) | 是 |
read() | 读取值(不移动所有权) | 是 |
replace(val) | 替换并返回旧值 | 是 |
add(n) / sub(n) | 偏移 n 个元素 | 是(解引用时) |
swap(other) | 与另一个指针交换值 | 是 |
write_bytes(val, count) | 填充字节 | 是 |
copy_from(src, count) | 从源复制(可重叠) | 是 |
copy_from_nonoverlapping(src, count) | 从源复制(不可重叠) | 是 |
is_null() | 检查空指针 | 否 |
cast::<U>() | 类型转换 | 否 |
*mut T 与 *const T 的关系
fn main() {
let mut value = 42;
// *mut T 可以隐式转换为 *const T
let mut_ptr: *mut i32 = &mut value;
let const_ptr: *const i32 = mut_ptr; // 自动转换
// *const T 转为 *mut T 需要显式 cast
let back_to_mut: *mut i32 = const_ptr as *mut i32;
// SAFETY: 所有指针来自同一个有效的可变变量
unsafe {
// 通过 *mut T 读写
*mut_ptr = 100;
println!("*mut T 写入后: {}", *mut_ptr);
// 通过 *const T 只读
println!("*const T 读取: {}", *const_ptr);
// 通过转换回来的 *mut T 写入
*back_to_mut = 200;
println!("转换后写入: {}", value);
}
}| 特性 | *const T | *mut T |
|---|---|---|
| 语义 | 只读 | 可读可写 |
| 解引用读 | 需要 unsafe | 需要 unsafe |
| 解引用写 | 不允许(需转为 *mut T) | 需要 unsafe |
| 转换为对方 | 需要 as *mut T | 自动(隐式) |
| 空指针 | null() | null_mut() |
基本示例
用 *mut T 实现一个简单的可增长缓冲区:
use std::alloc::{alloc, dealloc, realloc, Layout};
use std::ptr;
struct GrowableBuffer<T> {
ptr: *mut T,
len: usize, // 当前元素数量
capacity: usize, // 总容量
}
impl<T> GrowableBuffer<T> {
fn new() -> Self {
GrowableBuffer {
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: layout 大小 > 0(capacity > 0 且 T 不是 ZST)
let ptr = unsafe { alloc(layout) as *mut T };
if ptr.is_null() {
panic!("分配失败");
}
GrowableBuffer { ptr, len: 0, capacity }
}
fn push(&mut self, value: T) {
if self.len == self.capacity {
self.grow();
}
// SAFETY: grow 保证了 self.len < self.capacity,
// ptr.add(self.len) 在分配的内存范围内
unsafe {
self.ptr.add(self.len).write(value);
}
self.len += 1;
}
fn pop(&mut self) -> Option<T> {
if self.len == 0 {
return None;
}
self.len -= 1;
// SAFETY: self.len 之前 > 0,ptr.add(self.len) 指向有效的 T
Some(unsafe { self.ptr.add(self.len).read() })
}
fn get(&self, index: usize) -> Option<&T> {
if index < self.len {
// SAFETY: index < len,ptr.add(index) 指向有效的 T
Some(unsafe { &*self.ptr.add(index) })
} else {
None
}
}
fn get_mut(&mut self, index: usize) -> Option<&mut T> {
if index < self.len {
// SAFETY: index < len,有独占访问权(&mut self)
Some(unsafe { &mut *self.ptr.add(index) })
} else {
None
}
}
fn len(&self) -> usize {
self.len
}
fn capacity(&self) -> usize {
self.capacity
}
fn grow(&mut self) {
let new_capacity = if self.capacity == 0 { 4 } else { self.capacity * 2 };
let new_layout = Layout::array::<T>(new_capacity).unwrap();
let new_ptr = if self.ptr.is_null() {
// SAFETY: new_layout 大小 > 0
unsafe { alloc(new_layout) as *mut T }
} else {
let old_layout = Layout::array::<T>(self.capacity).unwrap();
// SAFETY: ptr 来自之前的 alloc/realloc,old_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_capacity;
}
}
impl<T> Drop for GrowableBuffer<T> {
fn drop(&mut self) {
if !self.ptr.is_null() {
// Drop 所有元素
for i in 0..self.len {
// SAFETY: i < len,每个元素都是有效的 T
unsafe { self.ptr.add(i).drop_in_place(); }
}
// 释放内存
let layout = Layout::array::<T>(self.capacity).unwrap();
// SAFETY: ptr 和 layout 来自之前的 alloc/realloc
unsafe { dealloc(self.ptr as *mut u8, layout); }
}
}
}
fn main() {
let mut buf = GrowableBuffer::new();
// 添加元素
for i in 0..10 {
buf.push(i * 10);
println!("push {}: len={}, capacity={}", i * 10, buf.len(), buf.capacity());
}
// 读取元素
println!("\n元素:");
for i in 0..buf.len() {
if let Some(val) = buf.get(i) {
print!("{} ", val);
}
}
println!();
// 修改元素
if let Some(val) = buf.get_mut(5) {
*val = 999;
}
println!("修改后 [5]: {:?}", buf.get(5));
// 弹出元素
while let Some(val) = buf.pop() {
print!("{} ", val);
}
println!("\n弹出后 len: {}", buf.len());
// 使用 String 类型(验证 Drop 正确性)
let mut str_buf = GrowableBuffer::new();
str_buf.push(String::from("Hello"));
str_buf.push(String::from("World"));
str_buf.push(String::from("Rust"));
println!("\n字符串缓冲区:");
for i in 0..str_buf.len() {
println!(" [{}]: {}", i, str_buf.get(i).unwrap());
}
// str_buf drop 时会正确释放所有 String
}常见问题
*问题一:mut T 和 &mut T 有什么区别?
&mut T 受借用检查器保护,保证独占访问,编译器验证生命周期。*mut T 没有这些保护,可以有多个指向同一数据的 *mut T,没有生命周期检查,可以为空。&mut T 更安全,*mut T 更灵活。
*问题二:可以同时有 mut T 和 &T 指向同一数据吗?
可以创建,但如果通过 *mut T 写入而 &T 还存活,就是未定义行为。这违反了 Rust 的别名规则——不可变引用存在时数据不能被修改。
*问题三:mut T 的 write 和直接赋值有什么区别?
ptr.write(val) 不会调用旧值的 Drop,适合初始化未初始化的内存。*ptr = val 会先 drop 旧值再写入新值,适合修改已初始化的数据。对于 Copy 类型没有区别。
*问题四:什么时候用 mut T 而不是 &mut T?
当需要绕过借用检查器时(如实现链表、构建自引用结构),当与 C 代码交互时(FFI),当需要在结构体内存储指向自身字段的指针时。日常代码应优先使用 &mut T。
适用场景
- 底层数据结构:链表、树、自定义分配器
- FFI:与 C 库交互的可变指针参数
- 内存管理:自定义的内存分配和释放
- 缓冲区操作:直接读写内存块
注意事项
- 创建
*mut T是安全的,读写需要 unsafe *mut T可以隐式转换为*const T,反向需要显式 castwrite不 drop 旧值,*ptr = val会 drop 旧值- 多个
*mut T指向同一数据时,必须手动避免数据竞争 - 不要在
&T存活时通过*mut T修改数据 - 释放内存前必须 drop 所有已初始化的元素
总结
*mut T 是可变裸指针,允许通过它读取和写入数据。与 &mut T 不同,*mut T 不受借用检查器约束,可以为空、悬垂,可以有多个指向同一数据。创建是安全的,读写需要 unsafe。*mut T 可以隐式转为 *const T。write 方法适合初始化未初始化内存(不 drop 旧值),直接赋值适合修改已初始化数据(会 drop 旧值)。实际使用中应将 *mut T 操作封装在安全的 API 后面,对外暴露带边界检查和生命周期管理的安全接口。主要用于底层数据结构、FFI 和内存管理。