深入了解Rust中trait的使用
古明地觉 人气:0楔子
前面我们提到过 trait，那么 trait 是啥呢？先来看个例子：
#[derive(Debug)]
struct Point<T> {
x: T,
}
impl<T> Point<T> {
fn m(&self) {
let var = self.x;
}
}
fn main() {
let p = Point { x: 123 };
}你觉得这段代码有问题吗？如果上一篇文章你还有印象的话，那么会很快发现是有问题的。因为方法 m 的第一个参数是引用，这就意味着方法调用完毕之后，结构体实例依旧保持有效，也意味着实例的所有成员值都保持有效。
但在方法 m 里面，我们将成员 x 的值赋给了变量 var。如果成员 x 的类型不是可 Copy 的，也就是数据不全在栈上，还涉及到堆，那么就会转移所有权，因为 Rust 默认不会拷贝堆数据。所以调用完方法 m 之后，成员 x 的值不再有效，进而使得结构体不再有效。
所以 Rust 为了避免这一点，在赋值的时候强制要求 self.x 的类型必须是可 Copy 的，但泛型 T 可以代表任意类型，它不满足这一特性。或者说 T 最终代表的类型是不是可 Copy 的，Rust 是不知道的，所以 Rust 干脆认为它不是可 Copy 的。
那么问题来了，虽然 T 可以代表任意类型，但如果我们赋的值决定了 T 代表的类型一定是可 Copy 的，那么可不可以告诉 Rust，让编译器按照可 Copy 的类型来处理呢？答案是可以的，而实现这一功能的机制就叫做 trait。
什么是 trait
trait 类似于 Go 里面的接口，相当于告诉编译器，某种类型具有哪些可以与其它类型共享的功能。
#[derive(Debug)]
struct Girl {
name: String,
age: i32
}
// trait 类似 Go 里面的接口
// 然后里面可以定义一系列的方法
// 这里我们创建了一个名为 Summary 的 trait
// 并在内部定义了一个 summary 方法
trait Summary {
// trait 里面的方法只需要写声明即可
fn summary(&self) -> String;
}
// Go 里面只要实现了接口里面的方法，便实现了该接口
// 但是在 Rust 里面必须显式地指明实现了哪一个 trait
// impl Summary for Girl 表示为类型 Girl 实现 Summary 这个 trait
impl Summary for Girl {
fn summary(&self) -> String {
// format! 宏用于拼接字符串，它的语法和 println! 一样
// 并且这两个宏都不会获取参数的所有权
// 比如这里的 self.name，format! 拿到的只是引用
format!("name: {}, age: {}", self.name, self.age)
}
}
fn main() {
let g = Girl{name: String::from("satori"), age: 16};
println!("{}", g.summary()); // name: satori, age: 16
}所以 trait 里面的方法只需要写上声明即可，实现交给具体的结构体来做。当然啦，trait 里面的方法也是可以有默认实现的。
#[derive(Debug)]
struct Girl {
name: String,
age: i32
}
trait Summary {
// 我们给方法指定了具体实现
fn summary(&self) -> String {
String::from("hello")
}
}
impl Summary for Girl {
// 如果要为类型实现 trait，那么要实现 trait 里面所有的方法
// 这一点和 Go 的接口是相似的，但 Go 里面实现接口是隐式的
// 只要你实现了某个接口所有的方法，那么默认就实现了该接口
// 但在 Rust 里面，必须要显式地指定实现了哪个 trait
// 同时还要实现该 trait 里的所有方法
// 但 Rust 的 trait 有一点特殊，Go 接口里面的方法只能是定义
// 而 trait 里面除了定义之外，也可以有具体的实现
// 如果 trait 内部已经实现了，那么这里就可以不用实现
// 不实现的话则用 trait 的默认实现，实现了则调用我们实现的
// 因此这里不需要定义任何的方法，它依旧实现了 Summary 这个 trait
// 只是我们仍然要通过 impl Summary for Girl 显式地告诉 Rust
// 如果只写 impl Girl，那么 Rust 则不认为我们实现了该 trait
}
fn main() {
let g = Girl{name: String::from("satori"), age: 16};
// 虽然没有 summary 方法，但因为实现了 Summary 这个 trait
// 而 trait 内部有 summary 的具体实现，所以不会报错
// 但如果 trait 里面的方法只有声明没有实现，那么就必须要我们手动实现了
println!("{}", g.summary()); // hello
}总结一下就是 trait 里面可以有很多的方法，这个方法可以只有声明，也可以同时包含实现。如果要为类型实现某个 trait，那么要通过 impl xxx for 进行指定，并且实现该 trait 内部定义的所有方法。但如果 trait 的某个方法已经包含了具体实现，那么我们也可以不实现，会使用 trait 的默认实现。
trait 作为参数
到目前为止，我们并没有看到 trait 的实际用途，但相信你也能猜出来它是做什么的。假设有一个函数，只要是实现了 info 方法的结构体实例，都可以作为参数传递进去，这时候应该怎么做呢？
struct Girl {
name: String,
age: i32,
}
struct Boy {
name: String,
age: i32,
salary: u32,
}
trait People {
fn info(&self) -> String;
}
// 为 Girl 和 Boy 实现 People 这个 trait
impl People for Girl {
fn info(&self) -> String {
format!("{} {}", &self.name, self.age)
}
}
impl People for Boy {
fn info(&self) -> String {
format!("{} {} {}", &self.name, self.age, self.salary)
}
}
// 定义一个函数，注意参数 p 的类型
// 如果是 p: xxx，则表示参数 p 的类型为 xxx
// 如果是 p: impl xxx，则表示参数 p 的类型任意，只要实现了xxx这个trait即可
fn get_info(p: impl People) -> String {
p.info()
}
fn main() {
let g = Girl {
name: String::from("satori"),
age: 16,
};
let b = Boy {
name: String::from("可怜的我"),
age: 26,
salary: 3000,
};
// 只要实现了 People 这个 trait
// 那么实例都可以作为参数传递给 get_info
println!("{}", get_info(g)); // satori 16
println!("{}", get_info(b)); // 可怜的我 26 3000
}然后以 trait 作为参数的时候，还有另外一种写法：
// 如果是 <T> 的话，那么 T 表示泛型，可以代表任意类型
// 但这里是 <T: People>，那么就不能表示任意类型了
// 它表示的应该是实现了 People 这个 trait 的任意类型
fn get_info<T: People>(p: T) -> String {
p.info()
}以上两种写法是等价的，但是第二种写法在参数比较多的时候，可以简化长度。
fn get_info<T: People>(p1: T, p2: T) -> String {
}
// 否则话要这么写
fn get_info(p1: impl People, p2: impl People) -> String {
}当然啦，一个类型并不仅仅可以实现一个 trait，而是可以实现任意多个 trait。
struct Girl {
name: String,
age: i32,
gender: String
}
trait People {
fn info(&self) -> String;
}
trait Female {
fn info(&self) -> String;
}
// 不同的 trait 内部可以有相同的方法
impl People for Girl {
fn info(&self) -> String {
format!("{} {}", &self.name, self.age)
}
}
impl Female for Girl {
fn info(&self) -> String {
format!("{} {} {}", &self.name, self.age, self.gender)
}
}
// 这里在 impl People 前面加上了一个 &
// 表示调用的时候传递的是引用
fn get_info1(p: &impl People) {
println!("{}", p.info())
}
fn get_info2<T: Female>(f: &T) {
println!("{}", f.info())
}
fn main() {
let g = Girl {
name: String::from("satori"),
age: 16,
gender: String::from("female")
};
get_info1(&g); // satori 16
get_info2(&g); // satori 16 female
}不同 trait 内部的方法可以相同也可以不同，而 Girl 同时实现了 People 和 Female 两个 trait，所以它可以传递给 get_info1，也可以传递给 get_info2。然后为 trait 实现了哪个方法，就调用哪个方法，所以两者的打印结果不一样。
那么问题来了，如果我在定义函数的时候，要求某个参数同时实现以上两个 trait，该怎么做呢？
// 我们只需要使用 + 即可
// 表示参数 p 的类型必须同时实现 People 和 Female 两个 trait
fn get_info1(p: impl People + Female) {
// 但由于 Poeple 和 Female 里面都有 info 方法
// 此时就不能使用 p.info() 了，这样 Rust 不知道该使用哪一个
// 应该采用下面这种做法，此时需要手动将引用传过去
People::info(&p);
Female::info(&p);
}
// 如果想接收引用的话，那么需要这么声明
// 因为优先级的原因，需要将 impl People + Female 整体括起来
fn get_info2(p: &(impl People + Female)) {}
// 或者使用类型泛型的写法
fn get_info3<T: People + Female>(p: T) {}最后还有一个更加优雅的写法：
// 显然这种声明方式要更加优雅，如果没有 where 的话
// 那么这个 T 就是可以代表任意类型的泛型
// 但这里出现了 where
// 因此 T 就表示实现了 People 和 Female 两个 trait 的任意类型
fn get_info<T>(p: T)
where
T: People + Female
{
}如果要声明多个实现 trait 的类型，那么使用逗号分隔。
fn get_info<T, W>(p1: T, p2: W)
where
T: People + Female,
W: People + Female
{
}可以看出，Rust 的语法表达能力还是挺丰富的。
trait 作为返回值
trait 也是可以作为返回值的。
struct Girl {
name: String,
age: i32,
gender: String,
}
trait People {
fn info(&self) -> String;
}
impl People for Girl {
fn info(&self) -> String {
format!("{} {}", &self.name, self.age)
}
}
fn init() -> impl People {
Girl {
name: String::from("satori"),
age: 16,
gender: String::from("female"),
}
}
fn main() {
let g = init();
println!("{}", g.info()); // satori 16
}一个 trait 可以有很多种类型实现，返回任意一个都是可以的。
实现一个 max 函数
这里我们定义一个函数 max，返回数组里面的最大元素，这里先假定数组是 i32 类型。
// arr 接收一个数组，我们将它声明为 &[i32]
// 这个声明比较特殊，我们举几个例子解释一下
// arr: [i32;5]，表示接收类型为 i32 长度为 5 的静态数组
// arr: Vec<f64>，表示接收类型为 f64 的动态数组，长度不限
/* arr: &[i32]，表示接收 i32 类型数组的引用
并且数组可以是动态数组，也可以是静态数组，长度不限
对于当前求最大值来说，我们不应该关注数组是静态的还是动态的
所以应该声明为 &[i32]，表示都支持
*/
fn max(arr: &[i32]) -> i32{
if arr.len() == 0 {
panic!("数组为空")
}
// 获取数组的第一个元素，然后和后续元素依次比较
let mut largest = arr[0];
for &item in arr {
if largest < item {
largest = item
}
}
largest
}
fn main() {
let largest = max(&vec![1, 23, 13, 4, 15]);
println!("{}", largest); // 23
}还是很简单的，但问题来了，如果我希望它除了支持整型数组外，还支持浮点型该怎么办呢？难道再定义一个函数吗？显然这是不现实的，于是我们可以考虑泛型。
fn max<T>(arr: &[T]) -> T {
if arr.len() == 0 {
panic!("数组为空")
}
let mut largest = arr[0];
for &item in arr {
if largest < item {
largest = item
}
}
largest
}使用泛型的话，代码就是上面这个样子，你觉得代码有问题吗？
不用想，问题大了去了。首先函数接收的是数组的引用，那么函数调用结束后，数组依旧保持有效，那么数组里面的元素显然也是有效的。但在给 largest 赋值的时候，等号右边是 arr[0]。如果数组里面的元素不是可 Copy 的，那么就会失去所有权，因为 Rust 不会拷贝堆数据，那这样的话数组之后就不能用了。所以这种情况 Rust 要求元素是可 Copy 的，但实际情况是不是呢？Rust 是不知道的，所以会报错，认为不是可 Copy 的，这是第一个错误。
然后是 for &item in arr，这段代码的错误和上面相同，在遍历的时候会依次将元素拷贝一份赋值给 item。但要求拷贝之后彼此互不影响，这就意味着数据必须全部在栈上。但 T 代表啥类型，该类型的数据是否全部在栈上 Rust 是不知道的，于是报错。
第三个错误就是 largest < item，因为这涉及到了比较，但 T 类型的数据能否比较呢？Rust 也是不知道的，所以报错。
因此基于以上原因，如果想让上述代码成立，那么必须对 T 进行一个限制。
fn max<T>(arr: &[T]) -> T
where
// 相当于告诉 Rust
// 这个 T 是可比较的、可 Copy 的
// 或者说 T 实现了 PartialOrd 和 Copy 这两个 trait
T: PartialOrd + Copy,
{
if arr.len() == 0 {
panic!("数组为空")
}
let mut largest = arr[0];
for &item in arr {
if largest < item {
largest = item
}
}
largest
}
fn main() {
let largest = max(&vec![1, 23, 13, 4, 15]);
println!("{}", largest); // 23
let largest = max(&vec![1.1, 23.1, 13.1, 4.1, 15.1]);
println!("{}", largest); // 23.1
}以上我们就实现了数组求最大值的逻辑，通过对 T 进行限制，告诉 Rust 泛型 T 代表的类型实现了 PartialOrd 和 Copy 这两个 trait。然后当我们调用的时候，Rust 就会检测类型是否合法：
显然当元素类型为 String 的时候就会报错，因为 Rust 检测到该类型没有实现 Copy 这个 trait。
那如果我希望，max 函数也支持 String 类型的数组呢？
fn max<T>(arr: &[T]) -> &T
where
// T 可以不实现 Copy trait
// 但必须实现 PartialOrd
T: PartialOrd,
{
if arr.len() == 0 {
panic!("数组为空")
}
// 这里必须要拿到引用，可能有人觉得调用 clone 可不可以
// 答案是不可以，因为这个函数不仅支持 String
// 还要支持整型、浮点型，所以只能获取引用
let mut largest = &arr[0];
// 因为 arr 是个引用，所以遍历出来的 item 也是元素的引用
for item in arr {
// 虽然这里表面上比较的是引用，但其实比较的是值
// 比如 let (a, b) = (11, 22)
// 那么 a < b 和 &a < &b 的结果是一样的
if largest < item {
largest = item
}
}
largest
}
fn main() {
let arr = &vec![String::from("A"), String::from("Z")];
println!("{}", max(arr)); // Z
let arr = &vec![1, 22, 11, 34, 19];
println!("{}", max(arr)); // 34
let arr = &vec![1.1, 22.1, 11.2, 34.3, 19.8];
println!("{}", max(arr)); // 34.3
}此时我们就实现了基础类型的比较，还是需要好好理解一下的。
加载全部内容