Rust 中的类型转换

1. `as` 运算符

as 运算符有点像 C 中的强制类型转换，区别在于，它只能用于原始类型(i32 、i64 、f32 、
f64 、 u8 、 u32 、 char 等类型),并且它是安全的。

例

在 Rust 中，不同的数值类型是不能进行隐式转换的，比如：

let b: i64 = 1i32;

会出现编译错误，提示无法进行类型转换。

error[E0308]: mismatched types
 --> src\main.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`
--> src\main.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块必须与类型本身存在于同一个模块中。
来自 F001 https://zhuanlan.zhihu.com/p/21568827
显然， 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 类型。

Rust 中的类型转换

1. as 运算符

2. Trait From<T> 和 Into<T>

3. 解引用强制多态

相关推荐

1. `as` 运算符

2. Trait `From<T>` 和 `Into<T>`