Rust 中 &i32 与 *i32 的深度解析

Rust 中 &i32 与 *i32 的深度解析

在 Rust 中，&i32 和 *i32 是两种完全不同的指针类型，它们在安全性、所有权和使用方式上有本质区别。以下是详细对比：

核心区别概览

详细对比分析

1. &i32 - 引用（安全指针）

fn safe_ref_example() {
    let num = 42;
    let ref_num: &i32 = # // 创建不可变引用
    
    // 自动解引用
    println!("Value: {}", *ref_num); 
    println!("Value: {}", ref_num); // 同样有效
    
    // 编译错误：不能同时存在可变和不可变引用
    // let mut_ref = &mut num;
}

2. *i32 - 裸指针（不安全指针）

fn raw_ptr_example() {
    let num = 42;
    let raw_ptr: *const i32 = &num as *const i32;
    
    // 必须使用 unsafe 块解引用
    unsafe {
        println!("Value: {}", *raw_ptr);
    }
    
    // 可能创建悬垂指针
    let dangling_ptr: *const i32;
    {
        let temp = 100;
        dangling_ptr = &temp as *const i32;
    } // temp 离开作用域
    // 危险：dangling_ptr 现在无效！
}

关键区别详解

1. 安全机制对比

2. 内存访问对比

3. 典型使用场景

&i32 场景：

// 函数参数传递
fn print_value(v: &i32) {
    println!("Value: {}", v);
}

// 结构体借用
struct Processor<'a> {
    data: &'a i32,
}

// 迭代器使用
let sum: i32 = vec![1, 2, 3].iter().map(|&x| x * 2).sum();

*i32 场景：

// C 语言交互
extern "C" {
    fn c_function(ptr: *mut i32);
}

// 自定义内存管理
unsafe fn allocate_buffer(size: usize) -> *mut u8 {
    let layout = std::alloc::Layout::array::<u8>(size).unwrap();
    std::alloc::alloc(layout)
}

// 高性能算法
unsafe fn fast_sum(ptr: *const i32, len: usize) -> i32 {
    let mut sum = 0;
    for i in 0..len {
        sum += *ptr.add(i);
    }
    sum
}

转换关系

1. 安全转换

// 引用 → 裸指针（安全）
let num = 42;
let ref_num: &i32 = #
let raw_ptr: *const i32 = ref_num as *const i32;

2. 不安全转换

// 裸指针 → 引用（不安全）
unsafe {
    let ref_back: &i32 = &*raw_ptr;
}

3. 转换注意事项

最佳实践指南

何时使用 &i32：

1. 99% 的日常 Rust 编程
2. 函数参数传递
3. 结构体字段借用
4. 实现 trait 对象 (&dyn Trait)

何时使用 *i32：

1. 与 C 库交互（FFI）
2. 实现底层数据结构（如自定义分配器）
3. 极端性能优化场景
4. 操作系统内核开发

安全使用裸指针的模式：

// 模式1：封装在安全API中
struct SafePointer {
    ptr: *mut i32,
    len: usize,
}

impl SafePointer {
    // 安全构造函数
    pub fn new(data: &mut [i32]) -> Self {
        SafePointer {
            ptr: data.as_mut_ptr(),
            len: data.len(),
        }
    }
    
    // 安全访问方法
    pub fn get(&self, index: usize) -> Option<&i32> {
        if index < self.len {
            unsafe { Some(&*self.ptr.add(index)) }
        } else {
            None
        }
    }
}

// 模式2：与生命周期绑定
struct GuardedPtr<'a> {
    ptr: *const i32,
    _marker: std::marker::PhantomData<&'a i32>,
}

impl<'a> GuardedPtr<'a> {
    pub fn new(reference: &'a i32) -> Self {
        GuardedPtr {
            ptr: reference as *const i32,
            _marker: std::marker::PhantomData,
        }
    }
    
    pub fn get(&self) -> &'a i32 {
        unsafe { &*self.ptr }
    }
}

性能对比

常见错误示例

错误1：悬垂引用

fn dangling_ref() -> &'static i32 {
    let x = 42;
    &x // 错误：返回局部变量引用
}

错误2：不安全裸指针使用

fn unsafe_ptr_demo() {
    let ptr: *const i32;
    {
        let value = 100;
        ptr = &value;
    } // value 被丢弃
    unsafe {
        println!("{}", *ptr); // 未定义行为！
    }
}

错误3：违反别名规则

fn alias_violation() {
    let mut data = 42;
    let ref1 = &data;
    let ref2 = &mut data; // 错误：同时存在可变和不可变引用
    
    println!("{}", ref1);
}

总结对比表

在 Rust 开发中，优先使用引用 &i32，只有在必要时（如 FFI 或底层系统编程）才使用裸指针 *i32，并且始终将其封装在安全的抽象中。