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

在 Rust 中，&i32 和 *i32 是兩種完全不同的指針類型，它們在安全性、所有權和使用方式上有本質區別。以下是詳細對比：

核心區別概覽

詳細對比分析

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

特性	說明
安全性	100% 安全，編譯器保證有效性
所有權	借用檢查器控制，不轉移所有權
解引用	自動解引用（Deref coercion）
使用場景	日常 Rust 編程
可變性	&i32（不可變）或 &mut 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 - 裸指針（不安全指針）

特性	說明
安全性	不安全，需要 unsafe 塊操作
所有權	無所有權概念，可能懸垂
解引用	必須顯式解引用（在 unsafe 中）
使用場景	FFI、底層系統編程、性能優化
可變性	*const i32（不可變）或 *mut i32（可變）
空值	可能為空（std::ptr::null()）
別名規則	無編譯時檢查，需手動保證安全

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. 內存訪問對比

操作	&i32	*i32
創建引用/指針	&value	&value as *const i32
解引用	自動或顯式 *ref	必須 unsafe { *ptr }
空指針	不可能	std::ptr::null()
指針算術	不支持	支持（ptr.offset(1)）
類型轉換	有限制（通過 trait）	自由轉換（as *mut u8）

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 }}
}

性能對比

操作	&i32	*i32
創建開銷	零成本抽象	零成本
解引用開銷	等同直接訪問	等同直接訪問
安全檢查開銷	編譯時（零運行時開銷）	無檢查（需手動驗證）
優化潛力	編譯器充分優化	同左，但需更多人工干預

常見錯誤示例

錯誤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);
}

總結對比表

特性	&i32	*const i32	*mut i32
安全性	安全	不安全	不安全
空值	不可能	可能	可能
可變性	不可變	不可變	可變
別名檢查	嚴格	無	無
生命周期	編譯器驗證	無保證	無保證
使用場景	常規編程	FFI/只讀訪問	FFI/寫訪問
解引用	安全	需 unsafe	需 unsafe
自動轉換	支持 Deref	不支持	不支持

在 Rust 開發中，優先使用引用 &i32，只有在必要時（如 FFI 或底層系統編程）才使用裸指針 *i32，并且始終將其封裝在安全的抽象中。