rust类型转换

1.From
From trait允许一种类型定义 “怎么根据另一种类型生成自己”，因此它提供了一种类型转换的简单机制。
比如，可以很容易地把 str 转换成 String：

let my_str = "hello";
let my_string = String::from(my_str);
1
2

也可以为自定义类型实现From

use std::convert::From;
#[derive(Debug)]
struct Number {
     value: i32,
}
impl From for Number {
     fn from(item: i32) -> Self {
         Number { value: item }
     }
}
fn main() {
     let num = Number::from(30);
     println!("My number is {:?}", num);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

2.Into
Into trait就是把 From trait倒过来而已。如果你为你的类型实现了 From，那么同时你也就免费获得了 Into。

例子

use std::convert::From;
#[derive(Debug)]
struct Number {
     value: i32,
}
impl From for Number {
     fn from(item: i32) -> Self {
         Number { value: item }
     }
}
fn main() {
     let int = 5;
     let num: Number = int.into();
     println!("My number is {:?}", num);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

（三）TryFrom 和 TryInto特性
类似于 From和Into，TryFrom 和 TryInto 是类型转换的通用trait。不同于From/Into的是，TryFrom和TryInto trait用于易出错的转换，也正因如此，其返回值是 Result 型。
例子

use std::convert::TryFrom;
use std::convert::TryInto;
#[derive(Debug, PartialEq)]
struct EvenNumber(i32);
impl TryFrom for EvenNumber {
     type Error = ();
     fn try_from(value: i32) -> Result {
         if value % 2 == 0 {
             Ok(EvenNumber(value))
         } else {
             Err(())
         }
     }
}
fn main() {
     // TryFrom
     assert_eq!(EvenNumber::try_from(8), Ok(EvenNumber(8)));
     assert_eq!(EvenNumber::try_from(5), Err(()));
     // TryInto
     let result: Result = 8i32.try_into();
     assert_eq!(result, Ok(EvenNumber(8)));
     let result: Result = 5i32.try_into();
     assert_eq!(result, Err(()));
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

（四）ToString 和 FromStr特性
1.ToString
要把其他类型转换成 String，只需要实现那个类型的 ToString trait。然而不要直接这么做，您应该实现fmt::Display trait，它会自动提供 ToString，并且还可以用来打印

例子

use std::fmt;
struct Circle {
     radius: i32
}
impl fmt::Display for Circle {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(f, "Circle of radius {}", self.radius)
     }
}
fn main() {
     let circle = Circle { radius: 6 };
     println!("{}", circle.to_string());
}
1
2
3
4
5
6
7
8
9
10
11
12
13

当然也可以直接实现ToString
例子

use std::string::ToString;
struct Circle {
     radius: i32
}
impl ToString for Circle {
     fn to_string(&self) -> String {
         format!("Circle of radius {:?}", self.radius)
     }
}
fn main() {
     let circle = Circle { radius: 6 };
     println!("{}", circle.to_string());
}
1
2
3
4
5
6
7
8
9
10
11
12
13

2.FromStr
把字符串转成其他类型。只要目标类型实现了 FromStr trait，就可以用 parse 把字符串转换成目标类型。
标准库中已经给无数类型实现了 FromStr。如果要转换到自定义类型，要手动实现 FromStr。

turbofish语法
语法格式

::<>
1

当把字符串转换成整数类型时，rust编译器无法确定要转换成哪种类型的整数，是u32还是i32。此时需要使用turbofish语法

实例

fn main() {
     let parsed: i32 = "5".parse().unwrap();     //显式指定类型
     let turbo_parsed = "10".parse::().unwrap();     //turbofish语法
     let sum = parsed + turbo_parsed;
     println!{"Sum: {:?}", sum};
}
1
2
3
4
5
6

（五）AsRef和AsMut特性
标准库中还有AsRef和AsMut两个trait，可以将值分别转换为不可变引用和可变引用。
比如，我们想设计一个允许传入&String和&str的函数

fn main(){
     let str1 = "123".to_string();
     let str2 = "456";
     test(str1);
     test(str2);
}
fn test(s: impl AsRef){
     println!("{}", s.as_ref());
}
1
2
3
4
5
6
7
8
9

如果我们自己定义一个类型，最好能实现AsRef这个Trait，它会给我们带来很多意想不到的实惠。

二、隐式转换

（一）自动强转点
发生自动强转的时机。
自动强转点有：
1.let语句中显式给出了类型。
例如，下面例子中 &mut 42自动强转成 &i8类型：

let _: &i8 = &mut 42;
1

2.静态项和常量项声明（类似于let语句）。
3.函数调用的参数
被强制的值是实参，它的类型被自动强转为形参的类型。
例如，下面例子中 &mut 42自动强转成 &i8类型：

fn bar(_: &i8) { }
fn main() {
     bar(&mut 42);
}
1
2
3
4

对于方法调用，接受者（self参数）只能使用非固定尺寸类型自动强转
4.实例化结构体、联合体或枚举变体的字段。
例如，下面例子中 &mut 42自动强转成 &i8类型：

struct Foo<'a> { x: &'a i8 }
fn main() {
     Foo { x: &mut 42 };
}
1
2
3
4

5.函数返回值
例如，下面例子中x将自动强转成 &dyn Display类型：

use std::fmt::Display;
fn foo(x: &u32) -> &dyn Display {
     x
}
1
2
3
4

如果在自动强转点中的表达式是传播型表达式，那么该表达式中的对应子表达式也是自动强转点。传播从这些新的自动强转点开始递归。传播表达式及其相关子表达式有：
1.数组字面量，其数组的类型为 [U; n]。数组字面量中的每个子表达式都是自动强转到类型U的自动强转点。
2.重复句法声明的数组字面量，其数组的类型为 [U; n]。重复子表达式是用于自动强转到类型U的自动强转点。
3.元组，其中如果元组是自动强转到类型 (U_0, U_1, …, U_n) 的强转点，则每个子表达式都是相应类型的自动强转点，比如第0个子表达式是到类型U_0的 自动强转点。
4.圆括号括起来的子表达式（(e)）：如果整个括号表达式的类型为U，则子表达式e是自动强转到类型U的自动强转点。
5.块：如果块的类型是U，那么块中的最后一个表达式（如果它不是以分号结尾的）就是一个自动强转到类型U的自动强转点。这里的块包括作为控制流语句的一部分的条件分支代码块，比如if/else，当然前提是这些块的返回需要有一个已知的类型。

（二）自动强转类型
1.T到U如果T是U的一个子类型 (反射性场景(reflexive case))
2.T_1到T_3当T_1可自动强转到T_2同时T_2又能自动强转到T_3 (传递性场景(transitive case))
注意这个还没有得到完全支持。
3.&mut T到 &T
4.*mut T到 *const T
5.&T到 *const T
6.&mut T到 *mut T
7.&T或 &mut T到 &U如果T实现了Deref Target = U。例如：

use std::ops::Deref;
struct CharContainer {
     value: char,
}
impl Deref for CharContainer {
     type Target = char;
     fn deref<'a>(&'a self) -> &'a char {
         &self.value
     }
}
fn foo(arg: &char) {}
fn main() {
     let x = &mut CharContainer { value: 'y' };
     foo(x); //&mut CharContainer自动强转成 &char.
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

8.&mut T到 &mut U如果T实现了DerefMut Target = U
9.TyCtor(T) 到TyCtor(U)，其中TyCtor(T) 是下列之一。TyCtor为类型构造器type constructor的简写。
&T
&mut T
*const T
*mut T
Box
并且U能够通过非固定尺寸类型自动强转得到。
10.非捕获闭包到函数指针
11.! 到任意T

（三）非固定尺寸类型自动强转
将固定尺寸类型转换为非固定尺寸类型
如果T可以自动强转成U，那么就会为T提供一个Unsize 的内置实现：
1.[T; n] 到 [T]
2.T到dyn U, 当T实现U + Sized, 并且U是对象安全的时。
3.Foo<…, T, …> 到Foo<…, U, …>, 当：
Foo是一个结构体。
T实现了Unsize。
Foo的最后一个字段是和T相关的类型。
如果这最后一个字段是类型Bar，那么Bar 实现了Unsized>。
T不是任何其他字段的类型的一部分。
此外，当T实现了Unsize 或CoerceUnsized> 时，类型Foo 可以实现CoerceUnsized>。这就允许Foo 提供一个到Foo 的非固定尺寸类型自动强转。
注：虽然非固定尺寸类型自动强转的定义及其实现已经稳定下来，但 Unsize 和 CoerceUnsized 这两个trait本身还没稳定下来，因此还不能直接用于稳定版的Rust。

// if分支的情况
let bar = if true {
     a
} else if false {
     b
} else {
     c
};
// 匹配臂的情况
let baw = match 42 {
     0 => a,
     1 => b,
     _ => c,     
};
// 数组元素的情况
let bax = [a, b, c];
// 多个返回项语句的闭包的情况
let clo = || {
     if true {
         a
     } else if false {
          b
     } else {
         c
     }
};
let baz = clo();
// 检查带有多个返回语句的函数的情况
fn foo() -> i32 {
     let (a, b, c) = (0, 1, 2);
     match 42 {
         0 => a,
          1 => b,
         _ => c,
     }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36