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