喜欢的话别忘了点赞、收藏加关注哦，对接下来的教程有兴趣的可以关注专栏。谢谢喵！(=･ω･=)
说句题外话，写这篇的时间比写所有权还还花的久，trait是真的比较难理解的概念。
10.4.1. 把trait作为参数
继续以上一篇文章中所讲的内容作为例子：
pub trait Summary {
fn summarize(&self) -> String;
}
pub struct NewsArticle {
pub headline: String,
pub location: String,
pub author: String,
pub content: String,
}
impl Summary for NewsArticle {
fn summarize(&self) -> String {
format!("{}, by {} ({})", self.headline, self.author, self.location)
}
}
pub struct Tweet {
pub username: String,
pub content: String,
pub reply: bool,
pub retweet: bool,
}
impl Summary for Tweet {
fn summarize(&self) -> String {
format!("{}: {}", self.username, self.content)
}
}
在这里我们再新定义一个函数notify，这函数接收NewsArticle和Tweet两个结构体，打印:“Breaking news:”，后面的内容是在参数上调用Summary上的summerize方法的返回值。
但这里有一个问题，它接收的参数是两个结构体，怎么样实现让参数可以是两个类型呢？
我们细想一下，这两个结构体的共同点是什么？没错，它们都实现了Summary这个trait。Rust对于这种情况提供了解决方案：
pub fn notify(item: &impl Summary) {
println!("Breaking news! {}", item.summarize());
}
只要把参数类型写成impl 某个trait就可以，这里两个结构体都实现了Summary这个trait，所以就写impl Summary，而又因为这个函数不需要数据的所有权，所以写成引用&impl Summary即可。如果又有其它数据类型实现了Summary，那它照样可以作为参数传进去。
impl trait的语法适用于简单情况，针对复杂情况，一般使用trait bound语法。
同样是上面的代码，用trait bound这么写：
pub fn notify<T: Summary>(item: &T) {
println!("Breaking news! {}", item.summarize());
}
这两种写法等价。
但是这种简单的写法看不出来trait bound的优势，再换一个例子。比如说，我要设计一个新的nnotify函数，叫它notify1吧，它接收两个参数，输出"Breaking news:"后面的内容是两个参数分别调用Summary上的summerize方法的返回值。
trait bound写法:
pub fn notify1<T: Summary>(item1: &T, item2: &T) {
println!("Breaking news! {} {}", item1.summarize(), item2.summarize());
}
impl trait写法:
pub fn notify1(item1: &impl Summary, item2: &impl Summary) {
println!("Breaking news! {} {}", item1.summarize(), item2.summarize());
}
前一种的函数签名显然比后一种的要跟好写也更直观。
而实际上，impl trait写法不过是trait bound写法的语法糖，所以impl trait写法不适合复杂情况也确实可以理解。
那么如果这个notify函数我需要它的参数是同时实现Display这个trait和Summary这个trait呢？也就是如果我有两个甚至两个以上的trait bounds该怎么写呢？
看例子：
pub fn notify_with_display<T: Summary + std::fmt::Display>(item: &T) {
println!("Breaking news! {}", item);
}
使用+号连接各个trait bound即可。
还有一点，由于Display不在预导入模块，所以写它的时候需要把路径写出来，也可以在代码开头先引入Display这个trait，也就是写use std::fmt::Display，这样就可以在写trait bound时直接写Display：
use std::fmt::Display
pub fn notify_with_display<T: Summary + Display>(item: &T) {
println!("Breaking news! {}", item);
}
别忘了impl trait这个语法糖哦，在这个语法糖里也是用+连接trait bounds:
use std::fmt::Display
pub fn notify_with_display(item: &impl Summary + Display) {
println!("Breaking news! {}", item);
}
这种写法有一个缺点，如果trait bounds过多，那么写的大量约束信息就会降低这个函数签名的可读性。为了解决这个问题，Rust提供了替代语法，就是在函数签名之后使用where字句来写trait bounds。
看个使用普通写法的写多个trait bounds:
use std::fmt::Display;
use std::fmt::Debug;
pub fn special_notify<T: Summary + Display, U: Summary + Debug>(item1: &T, item2: &U) {
format!("Breaking news! {} and {}", item1.summarize(), item2.summarize());
}
使用where字句重写的代码：
use std::fmt::Display;
use std::fmt::Debug;
pub fn special_notify<T, U>(item1: &T, item2: &U)
where
T: Summary + Display,
U: Summary + Debug,
{
format!("Breaking news! {} and {}", item1.summarize(), item2.summarize());
}
这种写法跟C#很相似。
10.4.2. 把trait作为返回类型
跟作为参数一样，把trait作为返回值也可以使用impl trait。如下例：
fn returns_summarizable() -> impl Summary {
Tweet {
username: String::from("horse_ebooks"),
content: String::from(
"of course, as you probably already know, people",
),
reply: false,
retweet: false,
}
}
这个语法有一个缺点：如果让返回类型实现了某个trait，那么必须保证这个函数/方法它所有的可能返回值都只能是一个类型。这是因为impl写法在工作上有一些限制导致Rust不支持。但Rust支持动态派发，之后会讲。
举个例子：
fn returns_summarizable(flag:bool) -> impl Summary {
if flag {
Tweet {
username: String::from("horse_ebooks"),
content: String::from(
"of course, as you probably already know, people",
),
reply: false,
retweet: false,
}
} else {
NewsArticle {
headline: String::from("Penguins win the Stanley Cup Championship!"),
location: String::from("Pittsburgh, PA, USA"),
author: String::from("Iceburgh, Scotland"),
content: String::from(
"The Pittsburgh Penguins once again are the best \
hockey team in the NHL.",
),
}
}
}
根据flag的布尔值一共有两种可能的返回值类型：Tweet类型和NewArticle，这时候编译器就会报错：
error[E0308]: `if` and `else` have incompatible types
--> src/lib.rs:42:9
|
32 | / if flag {
33 | | / Tweet {
34 | | | username: String::from("horse_ebooks"),
35 | | | content: String::from(
36 | | | "of course, as you probably already know, people",
... | |
39 | | | retweet: false,
40 | | | }
| | |_________- expected because of this
41 | | } else {
42 | | / NewsArticle {
43 | | | headline: String::from("Penguins win the Stanley Cup Championship!"),
44 | | | location: String::from("Pittsburgh, PA, USA"),
45 | | | author: String::from("Iceburgh, Scotland"),
... | |
49 | | | ),
50 | | | }
| | |_________^ expected `Tweet`, found `NewsArticle`
51 | | }
| |_______- `if` and `else` have incompatible types
|
help: you could change the return type to be a boxed trait object
|
31 | fn returns_summarizable(flag:bool) -> Box<dyn Summary> {
| ~~~~~~~ +
help: if you change the return type to expect trait objects, box the returned expressions
|
33 ~ Box::new(Tweet {
34 | username: String::from("horse_ebooks"),
...
39 | retweet: false,
40 ~ })
41 | } else {
42 ~ Box::new(NewsArticle {
43 | headline: String::from("Penguins win the Stanley Cup Championship!"),
...
49 | ),
50 ~ })
|
报错内容就是if和else下的返回类型是不兼容的（也就是不是同一种类型）。
使用trait bounds的实例
还记得在 10.2. 泛型 中提到的比大小的代码吗？我把代码粘在这里：
fn largest<T>(list: &[T]) -> T{
let mut largest = list[0];
for &item in list{
if item > largest{
largest = item;
}
}
largest
}
当时这么写报的错我也粘在这里：
error[E0369]: binary operation `>` cannot be applied to type `T`
--> src/main.rs:4:17
|
4 | if item > largest{
| ---- ^ ------- T
| |
| T
|
help: consider restricting type parameter `T`
|
1 | fn largest<T: std::cmp::PartialOrd>(list: &[T]) -> T{
| ++++++++++++++++++++++
在学了trait之后，是不是对这种写法和这个报错信息的理解又不同了呢？
先从报错代码来分析，报错信息是比较大小的运算符>不能应用在类型T上，下面的help这行又写了考虑限制类型参数T，再往下看下面还写到了具体的做法，就是在T后面添加std::cmp::PartialOrd(在trait bound里只需要写PartialOrd,因为它在预导入模块内，所以不需要把路径写全)，这实际上是一个用于实现比较大小的trait，试试按照提示来改：
fn largest<T: PartialOrd>(list: &[T]) -> T{
let mut largest = list[0];
for &item in list{
if item > largest{
largest = item;
}
}
largest
}
还是报错：
error[E0508]: cannot move out of type `[T]`, a non-copy slice
--> src/main.rs:2:23
|
2 | let mut largest = list[0];
| ^^^^^^^
| |
| cannot move out of here
| move occurs because `list[_]` has type `T`, which does not implement the `Copy` trait
|
help: if `T` implemented `Clone`, you could clone the value
--> src/main.rs:1:12
|
1 | fn largest<T: std::cmp::PartialOrd>(list: &[T]) -> T{
| ^ consider constraining this type parameter with `Clone`
2 | let mut largest = list[0];
| ------- you could clone this value
help: consider borrowing here
|
2 | let mut largest = &list[0];
| +
但报的错不一样了：无法从list里移动元素，因为list里的T没有实现Copy这个trait，下边的help说如果T实现了Clone这个trait，考虑克隆这个值。再下面还有一个help，说考虑使用借用的形式。
根据以上信息，有三种解决方案：
- 为泛型添加上
Copy这个trait - 使用克隆（得为泛型加上
Clone这个trait） - 使用借用
该选择哪个解决方案呢？这取决于你的需求。我想要这个函数能够处理数字和字符的集合，由于数字和字符都是存储在栈内存上的，所以都实现了Copy这个trait，那么只需要为泛型添加上Copy这个trait就可以：
fn largest<T: PartialOrd + Copy>(list: &[T]) -> T{
let mut largest = list[0];
for &item in list{
if item > largest{
largest = item;
}
}
largest
}
fn main() {
let number_list = vec![34, 50, 25, 100, 65];
let result = largest(&number_list);
println!("The largest number is {}", result);
let char_list = vec!['y', 'm', 'a', 'q'];
let result = largest(&char_list);
println!("The largest char is {}", result);
}
输出：
The largest number is 100
The largest char is y
那如果我想要这个函数实现String集合的对比呢？由于String是存储在堆内存上的，所以它并没有实现Copy这个trait,所以为泛型添加上Copy这个trait的思路就行不通。
那就试试克隆（得为泛型加上Clone这个trait）：
fn largest<T: PartialOrd + Clone>(list: &[T]) -> T{
let mut largest = list[0].clone();
for &item in list.iter() {
if item > largest{
largest = item;
}
}
largest
}
fn main() {
let string_list = vec![String::from("dev1ce"), String::from("Zywoo")];
let result = largest(&string_list);
println!("The largest string is {}", result);
}
输出：
error[E0507]: cannot move out of a shared reference
--> src/main.rs:3:18
|
3 | for &item in list.iter() {
| ---- ^^^^^^^^^^^
| |
| data moved here
| move occurs because `item` has type `T`, which does not implement the `Copy` trait
|
help: consider removing the borrow
|
3 - for &item in list.iter() {
3 + for item in list.iter() {
|
错误是数据无法移动，因为这种写法要求实现Copy这个trait，但String做不到，该怎么办呢？
那就不让数据移动，不要使用模式匹配，去掉&item前的&，这样item就从T变为了不可变引用&T。然后在比较的时候再使用解引用符号*，把&T解引用为T来与largest比较（下面的代码使用的就是这种），或在largest前加&来变为&T，总之要保持比较的两个变量类型一致：
fn largest<T: PartialOrd + Clone>(list: &[T]) -> T{
let mut largest = list[0].clone();
for item in list.iter() {
if *item > largest{
largest = item.clone();
}
}
largest
}
fn main() {
let string_list = vec![String::from("dev1ce"), String::from("Zywoo")];
let result = largest(&string_list);
println!("The largest string is {}", result);
}
记住T没有实现Copy这个trait，所以在给largest时要使用clone方法。
输出：
The largest string is dev1ce
这里这么写是因为返回值是T，如果把返回值改为&T就不需要克隆了：
fn largest<T: PartialOrd>(list: &[T]) -> &T{
let mut largest = &list[0];
for item in list.iter() {
if item > &largest{
largest = item;
}
}
largest
}
fn main() {
let string_list = vec![String::from("dev1ce"), String::from("Zywoo")];
let result = largest(&string_list);
println!("The largest string is {}", result);
}
但是记住，得在largest初始化时得把它设为&T，所以list[0]前得加上&表示引用。而且比较的时候也不能使用给item解引用的方法而得给largest加&。
10.4.3. 使用trait bound有条件的实现方法
在使用泛型类型参数的impl块上使用trait boud，就可以有条件地为实现了特定trait的类型来实现方法。
看个例子：
use std::fmt::Display;
struct Pair<T> {
x: T,
y: T,
}
impl<T> Pair<T> {
fn new(x: T, y: T) -> Self {
Self { x, y }
}
}
impl<T: Display + PartialOrd> Pair<T> {
fn cmp_display(&self) {
if self.x >= self.y {
println!("The largest member is x = {}", self.x);
} else {
println!("The largest member is y = {}", self.y);
}
}
}
无论T具体是什么类型,在Pair上都会有new函数，但只有T实现了Display和PartialOrd的时候才会有cmd_display这个方法。
也可以为实现了其它trait的任意类型有条件的实现某个trait。为满足trait bound的所有类型上实现trait叫做覆盖实现(blanket implementations)
以标准库中的to_string函数为例：
impl<T: Display> ToString for T {
// ......
}
它的意思就是对所满足display trait的类型都实现了ToString这个trait，这就是所谓的覆盖实现，也就是可以为任何实现了display trait的类型调用ToString这个trait上的方法。
以整数为例：
let s = 3.to_string();
这个操作之所以能实现是因为i32实现了Display trait，所以可以调用ToString上的to_string方法。
