裸指针 *const T ​

核心概念 ​

*const T 是 Rust 中的不可变裸指针(raw pointer),它直接存储一个内存地址,指向类型为 T 的数据。与引用(&T)不同,裸指针不受借用检查器的约束——可以为空、可以悬垂、可以不对齐、可以有多个指向同一数据的可变和不可变裸指针同时存在。创建裸指针本身是安全的,但解引用裸指针必须在 unsafe 块中进行。*const T 表示"只读"的语义,虽然这不像引用那样由编译器强制执行。裸指针主要用于 FFI(与 C 代码交互)、实现底层数据结构以及需要绕过借用检查器的特殊场景。

rust
fn main() {
    let value = 42;

    // 从引用创建裸指针(安全操作)
    let ptr: *const i32 = &value as *const i32;

    // 也可以用 &raw const 语法(Rust 2024+)
    let ptr2: *const i32 = &raw const value;

    // 打印指针地址
    println!("指针地址: {:p}", ptr);
    println!("指针地址: {:p}", ptr2);

    // 解引用需要 unsafe
    // SAFETY: ptr 来自有效的引用,value 在当前作用域有效
    let read_value = unsafe { *ptr };
    println!("读取值: {}", read_value);

    // 裸指针可以为空
    let null_ptr: *const i32 = std::ptr::null();
    println!("空指针: {:p}", null_ptr);
    println!("是否为空: {}", null_ptr.is_null());
}

创建 *const T 的方式 ​

rust
fn main() {
    // === 从引用转换 ===
    let x = 100;
    let ptr1: *const i32 = &x;           // 隐式转换
    let ptr2: *const i32 = &x as *const i32;  // 显式转换

    // === 从 &raw const 语法(Rust 2024+)===
    let ptr3: *const i32 = &raw const x;

    // === 从可变引用转换 ===
    let mut y = 200;
    let ptr4: *const i32 = &y as *const i32;  // &mut T 可以转为 *const T

    // === 空指针 ===
    let null: *const i32 = std::ptr::null();

    // === 从整数地址创建(极不安全)===
    let addr: usize = 0x1000;
    let ptr_from_addr = addr as *const i32;  // 几乎一定是无效的

    // === 从 Box/Vec 等获取 ===
    let boxed = Box::new(42);
    let ptr5: *const i32 = Box::into_raw(boxed);  // Box 转为裸指针

    // 注意:Box::into_raw 后需要手动管理内存
    // SAFETY: ptr5 来自 Box::into_raw,有效且对齐
    let boxed_back = unsafe { Box::from_raw(ptr5 as *mut i32) };
    println!("从 Box 获取: {}", boxed_back);

    // === 从切片获取 ===
    let arr = [1, 2, 3, 4, 5];
    let ptr6: *const i32 = arr.as_ptr();  // 指向第一个元素

    // SAFETY: ptr1-ptr4 都来自有效的局部变量
    unsafe {
        println!("ptr1: {}", *ptr1);
        println!("ptr2: {}", *ptr2);
        println!("ptr3: {}", *ptr3);
        println!("ptr4: {}", *ptr4);
        println!("ptr6: {}", *ptr6);
    }
    println!("null: {:p}, is_null: {}", null, null.is_null());
}

*const T 的方法 ​

rust
fn main() {
    let data = [10, 20, 30, 40, 50];
    let ptr = data.as_ptr();

    // === is_null ===
    println!("是否为空: {}", ptr.is_null());

    // === offset / add / sub ===
    // SAFETY: 所有偏移都在 data 数组范围内
    unsafe {
        // add:向前移动 n 个 T 大小的单位
        let second = ptr.add(1);
        println!("第二个元素: {}", *second);

        let fourth = ptr.add(3);
        println!("第四个元素: {}", *fourth);

        // sub:向后移动
        let back = fourth.sub(2);
        println!("回退两个: {}", *back);

        // offset:可正可负
        let moved = ptr.offset(2);
        println!("偏移+2: {}", *moved);
    }

    // === cast ===
    // 类型转换(不改变地址)
    let byte_ptr: *const u8 = ptr.cast::<u8>();
    println!("转换为 *const u8: {:p}", byte_ptr);

    // === wrapping_add / wrapping_sub ===
    // 允许溢出的偏移(不触发未定义行为,但解引用可能不安全)
    let wrapped = ptr.wrapping_add(100);  // 可能越界,但创建本身不是 UB
    println!("wrapping_add(100): {:p}", wrapped);

    // === offset_from ===
    let first = data.as_ptr();
    let third = unsafe { first.add(2) };
    // SAFETY: 两个指针来自同一个数组
    let distance = unsafe { third.offset_from(first) };
    println!("距离: {} 个元素", distance);
}
方法说明安全性
is_null()检查是否为空指针安全
add(n)向前偏移 n 个元素unsafe(可能越界)
sub(n)向后偏移 n 个元素unsafe(可能越界)
offset(n)偏移 n 个元素(可负)unsafe
cast::<U>()类型转换安全(不解引用)
wrapping_add(n)允许溢出的偏移安全(创建时)
offset_from(origin)计算两指针的距离unsafe
read()读取指针指向的值unsafe
read_unaligned()读取可能未对齐的值unsafe

*const T 与 &T 的区别 ​

rust
fn main() {
    let value = 42;

    // &T:受借用检查器保护
    let ref_val: &i32 = &value;

    // *const T:不受借用检查器保护
    let ptr_val: *const i32 = &value as *const i32;

    // 引用保证非空、对齐、有效
    println!("引用: {}", ref_val);

    // 裸指针不保证任何东西
    // SAFETY: ptr_val 来自有效引用
    println!("指针: {}", unsafe { *ptr_val });

    // 引用有生命周期约束
    // let dangling_ref: &i32;
    // {
    //     let temp = 10;
    //     dangling_ref = &temp;  // 编译错误:temp 活得不够久
    // }

    // 裸指针没有生命周期约束(编译器不检查)
    let dangling_ptr: *const i32;
    {
        let temp = 10;
        dangling_ptr = &temp as *const i32;
        // temp 离开作用域后 dangling_ptr 变成悬垂指针
    }
    // 解引用 dangling_ptr 是未定义行为!
    // unsafe { println!("{}", *dangling_ptr); }  // 危险!
    println!("悬垂指针地址: {:p} (不要解引用!)", dangling_ptr);
}
特性&T(引用)*const T(裸指针)
空值不可能可以为 null
对齐保证对齐不保证
有效性保证指向有效数据不保证
生命周期编译器检查不检查
借用规则受检查不受检查
解引用安全需要 unsafe
多个同时存在受限(不可变或独占)无限制

基本示例 ​

用 *const T 实现一个只读的内存视图:

rust
use std::slice;
use std::fmt;

/// 只读内存视图:指向一段连续内存,不拥有数据
struct MemoryView<T> {
    ptr: *const T,
    len: usize,
}

impl<T> MemoryView<T> {
    /// 从切片创建视图(安全接口)
    fn from_slice(data: &[T]) -> Self {
        MemoryView {
            ptr: data.as_ptr(),
            len: data.len(),
        }
    }

    /// 从裸指针创建视图
    ///
    /// # Safety
    /// - ptr 必须非空且正确对齐
    /// - ptr 必须指向连续的 len 个已初始化的 T 值
    /// - 在 MemoryView 的使用期间,这些数据不能被修改或释放
    unsafe fn from_raw(ptr: *const T, len: usize) -> Self {
        MemoryView { ptr, len }
    }

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

    fn is_empty(&self) -> bool {
        self.len == 0
    }

    /// 获取指定索引的元素(安全接口,带边界检查)
    fn get(&self, index: usize) -> Option<&T> {
        if index < self.len {
            // SAFETY: 已检查 index < len,构造时保证了 ptr 有效
            Some(unsafe { &*self.ptr.add(index) })
        } else {
            None
        }
    }

    /// 转换为切片(安全接口)
    fn as_slice(&self) -> &[T] {
        if self.len == 0 {
            &[]
        } else {
            // SAFETY: 构造时保证了 ptr 非空、对齐、指向 len 个有效 T
            unsafe { slice::from_raw_parts(self.ptr, self.len) }
        }
    }

    /// 创建子视图
    fn sub_view(&self, start: usize, len: usize) -> Option<Self> {
        if start + len > self.len {
            return None;
        }
        // SAFETY: start + len <= self.len,偏移不越界
        Some(MemoryView {
            ptr: unsafe { self.ptr.add(start) },
            len,
        })
    }

    /// 获取原始指针
    fn as_ptr(&self) -> *const T {
        self.ptr
    }
}

impl<T: fmt::Debug> fmt::Debug for MemoryView<T> {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "MemoryView({:?})", self.as_slice())
    }
}

fn main() {
    let data = vec![10, 20, 30, 40, 50, 60, 70, 80];

    // 从切片创建视图
    let view = MemoryView::from_slice(&data);
    println!("完整视图: {:?}", view);
    println!("长度: {}", view.len());

    // 按索引访问
    for i in 0..view.len() {
        if let Some(val) = view.get(i) {
            print!("{} ", val);
        }
    }
    println!();

    // 越界访问返回 None
    println!("越界: {:?}", view.get(100));

    // 子视图
    if let Some(sub) = view.sub_view(2, 4) {
        println!("子视图 [2..6]: {:?}", sub);
    }

    // 转换为切片使用迭代器
    let sum: i32 = view.as_slice().iter().sum();
    println!("总和: {}", sum);

    // 指针地址
    println!("起始地址: {:p}", view.as_ptr());

    // 空视图
    let empty: MemoryView<i32> = MemoryView::from_slice(&[]);
    println!("空视图: {:?}, 为空: {}", empty, empty.is_empty());
}

常见问题 ​

*问题一:创建 const T 需要 unsafe 吗?

不需要。创建裸指针本身是安全的——&x as *const T、std::ptr::null() 等都不需要 unsafe。只有解引用(*ptr)才需要 unsafe 块。

**问题二:const T 可以转换为 mut T 吗?

可以,通过 ptr as *mut T。但如果原始数据是不可变的,通过 *mut T 写入会导致未定义行为。这个转换本身不需要 unsafe,但之后的写操作需要。

*问题三:const T 和 usize 可以互相转换吗?

可以。ptr as usize 得到地址值,addr as *const T 从地址创建指针。但从任意地址创建的指针几乎一定是无效的,解引用会导致未定义行为。

*问题四:const T 可以跨线程使用吗?

裸指针默认不实现 Send 和 Sync。如果你确信指针指向的数据在多线程环境下是安全的,可以 unsafe impl Send/Sync。

适用场景 ​

  • FFI:与 C 代码交互时接收和传递指针
  • 底层数据结构:链表、树等需要裸指针的结构
  • 内存映射:读取内存映射文件或硬件寄存器
  • 性能优化:绕过边界检查读取数组元素

注意事项 ​

  • 创建裸指针是安全的,解引用需要 unsafe
  • *const T 不保证非空、对齐、有效
  • 没有生命周期检查,容易产生悬垂指针
  • 裸指针不实现 Send 和 Sync
  • 优先使用引用(&T),只在必要时用裸指针
  • 解引用前必须确认指针非空、对齐、指向有效内存

总结 ​

*const T 是 Rust 的不可变裸指针,存储一个内存地址,指向类型 T 的数据。与引用 &T 不同,裸指针不受借用检查器约束——可以为空、悬垂、不对齐。创建裸指针是安全操作(从引用转换、null()、as_ptr() 等),但解引用必须在 unsafe 块中。裸指针提供了 add、sub、offset、cast、read 等方法用于指针运算。实际使用中应将裸指针操作封装在安全的 API 后面,对外暴露带边界检查的安全接口。裸指针主要用于 FFI、底层数据结构和性能优化。