Rust 中的類型轉換
- 2019 年 11 月 7 日
- 筆記
1. as 運算符
as 運算符有點像 C 中的強制類型轉換，區別在於，它只能用於原始類型(i32 、i64 、f32 、
f64 、 u8 、 u32 、 char 等類型),並且它是安全的。
例
在 Rust 中，不同的數值類型是不能進行隱式轉換的，比如：
let b: i64 = 1i32;會出現編譯錯誤，提示無法進行類型轉換。
error[E0308]: mismatched types --> srcmain.rs:2:18 | 2 | let b: i64 = 1i32; | ^^^^ expected i64, found i32 help: change the type of the numeric literal from `i32` to `i64`這時可以使用as 進行轉換。
let b: i64 = 1i32 as i64;-
為什麼它是安全的？
嘗試以下程式碼：
let b = 1i32 as char;編譯器錯誤：
error[E0604]: only `u8` can be cast as `char`, not `i32` --> srcmain.rs:2:13 | 2 | let b = 1i32 as char; | ^^^^^^^^^^^^可見在不相關的類型之間，Rust 會拒絕轉換，這也避免了運行時錯誤。
2. Trait From<T> 和 Into<T>
上文說到，as 運算符之能在原始類型之間進行轉換，那麼對於 Struct 和 Enum 這樣的類型該如何進行轉換呢？ 這就是我們這節的內容 From<T> 和 Into<T> 。
先來看一看這兩個 Trait 的結構。
pub trait From<T> { fn from(T) -> Self; } pub trait Into<T> { fn into(self) -> T; }很簡單，From<T> 有一個 from 方法，Into<T> 有一個 into 方法。
一般來說，我們應該盡量優先選擇實現 From<T> 而不是 Into<T> ，因為當你為 U 實現 From<T> ，這意味著你同時也為 T 隱式實現了 Into<U> 。
來看個例子
fn main() { println!("Hello, world!"); let b: Complex = 1.into(); println!("{:?}", b); } #[derive(Debug)] struct Complex { re: i32, im: i32 } impl From<i32> for Complex{ fn from(re: i32) -> Self { Complex{ re, im:0 } } }當我為 Complex 實現 From<i32> 後，我也可以在 i32 上使用 into 方法，轉換到 Complex 。
原始類型實現了與 as 轉換相對應的 From<T> 與 Into<T> 。
當你為 U 實現 From<T> 之後，你要確保這個轉換一定能成功，如若有失敗的可能，你應該選擇為 U 實現 TryFrom<T> 。
-
什麼時候該使用
Into<T>Into<T>被設計出來，總有該用到的地方。那什麼時候該使用呢？先複習一下 Rust 中的
孤兒原則在聲明trait和impl trait的時候，Rust規定了一個Orphan Rule(孤兒規則)：impl塊要麼與trait的聲明在同一個的crate中，要麼與類型的聲明在同一個crate中。
也就是說，不能在一個crate中，針對一個外部的類型，實現一個外部的trait。
因為在其它的crate中，一個類型沒有實現一個trait，很可能是有意的設計。
如果我們在使用其它的crate的時候，強行把它們「拉郎配」，是會製造出bug的。
比如說，我們寫了一個程式，引用了外部庫lib1和lib2，lib1中聲明了一個trait T，lib2中聲明了一個struct S ，我們不能在自己的程式中針對S實現T。
這也意味著，上游開發者在給別人寫庫的時候，尤其要注意。
一些比較常見的標準庫中的 trait，比如 Display Debug ToString Default 等，應該儘可能地提供好。
否則，使用這個庫的下游開發者，是沒辦法幫我們把這些 trait 實現的。
同理，如果是匿名impl，那麼這個impl塊必須與類型本身存在於同一個模組中。
顯然，
From<T>不屬於當前 crate ，當你要實現當前 crate 中的類型T轉換到其他 crate 中的類型U時，如果選擇為U實現From<T>，由於孤兒原則，編譯器會阻止你這麼做。這時我們就可以選擇為T實現Into<U>。注意，和
From<T>不同，實現Into<U>之後並不會隱式實現From<T>，這點需特別注意。 -
From<T>的妙用回憶一下 Rust 的
?操作符，它被用於 返回值為Result<T,E>或者Option<T>的函數。回想一下，它是如何處理Err(E)的。fn apply() -> Result<i32,i32> { Err(1) } fn main() -> Result<(),i64> { let a = apply()?; Ok(()) }上面的例子是可以通過編譯的，既然 Rust 中的數值類型是不能隱式轉換的，那麼，當返回
Err(i32)時是如何轉換到Err(i64)的呢？這其實是一個 Rust 的語法糖。展開後的程式碼類似於下面：fn apply() -> Result<i32,i32> { Err(1) } fn main() -> Result<(),i64> { let a = match apply() { Ok(v) => v, Err(e) => return Err(i64::from(e)), }; Ok(()) }也就是說，Rust 會自動調用目標類
from方法進行轉換。
3. 解引用強制多態
這次先看一個例子：
fn print(message: &str) { println!("{}",message); } fn main() { let message: String = "message".to_string(); print(&message); }print 的形參是 &str 類型，然而在 main 中，我傳遞卻是一個 &String 類型的實參。明顯，這兩個類型不相同！！Rust 為什麼會通過這樣的程式碼呢？
沒錯，這就是 Rust 的 解引用強制多態。
首先，需要了解一個 Deref Trait 。
#[lang = "deref"] pub trait Deref { type Target: ?Sized; #[must_use] fn deref(&self) -> &Self::Target; }deref 方法返回一個 &Target 類型的引用。
回憶一下 Rust 中的解引用語法，當 ref 是一個引用或智慧指針時，我們可以使用 *ref 的方式解引用。這是類似一個語法糖，對於 *ref 這種寫法，寫全應該時 *(ref.deref()) 。
回想 Box<T> 的使用，Box<T> 實現了 Deref ，它的 deref 方法返回 &T 的引用，然後使用解引用運算符 * ，我們順利拿到一個 T 類型的數據。也就是，你可以通過實現 Deref 以重載解引用運算符。
Deref 和這節的內容有什麼關係呢？
當 T 實現了 Deref<Target=U> 時，對於需要 &U 的地方，你可以提供一個 &T 類型的數據，Rust會為你自動調用 deref 方法，而這個過程可以重複多次。
比如，我自定義類型 P 實現了 Deref<Target=String> ,那麼可以把 &P 類型變數傳遞給一個 &str 類型變數。&P -> &String -> &str ,偽程式碼： &P.deref().deref() 。
回到這節開頭的例子，print(&message) 相當於 print((&message).deref()) ，正好是一個 &str 類型。
