裸指针 *mut T ​

核心概念 ​

*mut T 是 Rust 中的可变裸指针,存储一个内存地址并允许通过该地址读取和写入类型 T 的数据。与 *const T 相比,*mut T 在语义上表示"可以修改指向的数据"。和所有裸指针一样,*mut T 不受借用检查器约束,没有生命周期限制,可以为空或悬垂。创建 *mut T 是安全操作,但通过它读写数据需要在 unsafe 块中进行。*mut T 在 FFI、底层数据结构实现和需要可变访问的低级操作中广泛使用。

rust
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 的创建方式 ​

rust
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 的方法 ​

rust
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 的关系 ​

rust
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 实现一个简单的可增长缓冲区:

rust
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,反向需要显式 cast
  • write 不 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 和内存管理。