Rust 编程视频教程（进阶）——002 trait_t t 00t t tt rusts ttt 00000 00+00t

视频地址

头条地址：https://www.ixigua.com/i6775861706447913485
Ｂ站地址：https://www.bilibili.com/video/av81202308/

讲解内容

1、trait用于定义与其它类型共享的功能，类似于其它语言中的接口。
（1）可以通过trait以抽象的方式定义共享的行为。
（2）可以使用trait bounds指定泛型是任何拥有特定行为的类型。

2、定义trait

pub trait GetInformation{
	fn get_name(&self) -> &String;
	fn get_age(&self) -> u32;
}
1
2
3
4

3、实现trait

//-----------------------------------------
pub struct Student {
	pub name: String,
	pub age: u32,
}

impl GetInformation for Student {
	fn get_name(&self) -> &String {
		&self.name
	}
	fn get_age(&self) -> u32 {
		self.age
	}
}
//----------------------------------------
pub struct Teacher {
	pub name: String,
	pub age: u32,
}
impl GetInformation for Teacher {
	fn get_name(&self) -> &String {
		&self.name
	}
	fn get_age(&self) -> u32 {
		self.age
	}
}
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

4、默认实现：可以在定义trait的时候提供默认的行为，trait的类型可以使用默认的行为。
例子：

trait SchoolName {
	fn get_school_name(&self) -> String {
		String::from("HongXingSchool")
	}
}

//下面使用默认实现
pub struct Teacher {
	pub name: String,
	pub age: u32,
}

impl SchoolName for Teacher {}
fn main() {
	let t = Teacher{ name: String::from("andy"), age: 32};
	let t_school_name = t.get_school_name();
	println!("teacher school name = {}", t_school_name);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

5、trait作为参数
例子：

pub fn print_information(item: impl GetInformation) {
	println!("name = {}", item.get_name());
	println!("age = {}", item.get_age());
}
1
2
3
4

6、trait bound语法
上面的例子可以写成：

pub fn print_information<T: GetInformation>(item: T) {
	println!("name = {}", item.get_name());
	println!("age = {}", item.get_age());
}
1
2
3
4

7、通过+指定多个trait bound

pub trait GetName {
	fn get_name(&self) -> &String;
}

pub trait GetAge {
	fn get_age(&self) -> u32;
}

//写法一
pub fn print_information<T: GetName+GetAge>(item: T) {
	println!("name = {}", item.get_name());
	println!("age = {}", item.get_age());
}

//写法二，使用where
pub fn print_information<T>(item: T)
	where T: GetName+GetAge 
{
	println!("name = {}", item.get_name());
	println!("age = {}", item.get_age());
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

8、返回trait的类型

fn produce_item_with_information() -> impl GetInformation {
	Teacher {
		name: String::from("Andy"),
		age: 32,
	}
}
1
2
3
4
5
6

但是，需要注意的是，只能返回单一类型，以下实现会出错（因为返回了两个类型）：

fn produce_item_with_information(is_teacher: bool) -> impl GetInformation {
	if is_teacher {
		Teacher {
			name: String::from("Andy"),
			age: 32,
		}
	} else {
		Student {
			name: String::from("harden"),
			age: 47,
		}
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13

9、复习之前的largest例子

fn largest<T：PartialOrd + Copy>(list: &[T]) -> T { //注意，要实现比较和复制的trait才行，否则报错
	let mut largest = list[0];
	for &item in list.iter() {
		if item > largest {
			largest = item;
		}
	}
	largest
}

fn main(){
	let number_list = vec![1, 2, 22, 3, 42];
	let r1 = largest_i32(&number_list);
	println!("r1 = {}", r1);
	let char_list = vec!['a', 'y', 'c', 'd'];
	let r2 = largest_char(&char_list);
	println!("r2 = {}", r2);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

10、使用trait bound有条件地的实现方法

pub trait GetName {
	fn get_name(&self) -> &String;
}

pub trait GetAge {
	fn get_age(&self) -> u32;
}

struct PeopleMatchInformation<T, U> {
	master: T,
	employee: U,
}

impl <T: GetName+GetAge , U: GetName+GetAge> PeopleMatchInformation<T, U> {
	fn print_all_information(&self) {
		println!("teacher name = {}", self.master.get_name());
		println!("teacher age = {}", self.master.get_age());
		println!("student name = {}", self.employee.get_name());
		println!("student age = {}", self.employee.get_age());
	}
}

//使用
pub struct Teacher {
	pub name: String,
	pub age: u32,
}

impl GetName for Teacher {
	fn get_name(&self) -> &String {
		&(self.name)
	}
}

impl GetAge for Teacher {
	fn get_age(&self) -> u32{
		self.age
	}
}

pub struct Student{
	pub name: String,
	pub age: u32,
}

impl GetName for Student {
	fn get_name(&self) -> &String {
		&(self.name)
	}
}

impl GetAge for Student {
	fn get_age(&self) -> u32{
		self.age
	}
}

fn main() {
	let t = Teacher{ name: String::from("andy"), age: 32};
	let s = Student {name: String::from("harden"), age: 47};
	let m = PeopleMatchInformation{master: t, employee: s};
	m.print_all_information();
}
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
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

11、对任何实现了特定trait的类型有条件的实现trait
例如：

pub trait GetName {
	fn get_name(&self) -> &String;
}

pub trait PrintName {
	fn print_name(&self) ;
}

impl<T: GetName> PrintName for T {
	fn print_name(&self) {
		println!("name = {}", self.get_name());
	}
}

//----------使用----------------
pub struct Student{
	pub name: String,
}

impl GetName for Student {
	fn get_name(&self) -> &String {
		&(self.name)
	}
}

fn main() {
	let s = Student{name: String::from("Andy")};
	s.print_name(); //student实现了GetName trait，因此可是直接使用PrintName trait中的函数print_name
}
//引申：这种方式类似于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