第16章特质 trait on 编程那些事儿

01-派生

Thu, 20 Aug 2026 21:20:00 +0800

译文 · 基于 Rust By Example

原文链接: https://doc.rust-lang.org/stable/rust-by-example/trait/derive.html

派生

通过 #[derive] 属性，编译器能够提供某些 trait 的基本实现。如果需要更复杂的行为，这些 trait 也可以手动实现。

下面是可以自动派生的 trait：

比较 trait: Eq, PartialEq, Ord, PartialOrd
Clone, 用来从 &T 创建副本 T。
Copy，使类型具有 “复制语义”（copy semantics）而非 “移动语义”（move semantics）。
Hash，从 &T 计算哈希值（hash）。
Default, 创建数据类型的一个空实例。
Debug，使用 {:?} formatter 来格式化一个值。

 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


// `Centimeters`，可以比较的元组结构体
#[derive(PartialEq, PartialOrd)]
struct Centimeters(f64);

// `Inches`，可以打印的元组结构体
#[derive(Debug)]
struct Inches(i32);

impl Inches {
 fn to_centimeters(&self) -> Centimeters {
 let &Inches(inches) = self;

 Centimeters(inches as f64 * 2.54)
 }
}

// `Seconds`，不带附加属性的元组结构体
struct Seconds(i32);

fn main() {
 let _one_second = Seconds(1);

 // 报错：`Seconds` 不能打印；它没有实现 `Debug` trait
 //println!("One second looks like: {:?}", _one_second);
 // 试一试 ^ 取消此行注释

 // 报错：`Seconds`不能比较；它没有实现 `PartialEq` trait
 //let _this_is_true = (_one_second == _one_second);
 // 试一试 ^ 取消此行注释

 let foot = Inches(12);

 println!("One foot equals {:?}", foot);

 let meter = Centimeters(100.0);

 let cmp =
 if foot.to_centimeters() < meter {
 "smaller"
 } else {
 "bigger"
 };

 println!("One foot is {} than one meter.", cmp);
}

参见

derive

02-使用 `dyn` 返回 trait

Thu, 20 Aug 2026 21:20:00 +0800

译文 · 基于 Rust By Example

原文链接: https://doc.rust-lang.org/stable/rust-by-example/trait/dyn.html

使用 `dyn` 返回 trait

Rust 编译器需要知道每个函数的返回类型需要多少空间。这意味着所有函数都必须返回一个具体类型。与其他语言不同，如果你有个像 Animal 那样的的 trait，则不能编写返回 Animal 的函数，因为其不同的实现将需要不同的内存量。

03-运算符重载

Thu, 20 Aug 2026 21:20:00 +0800

译文 · 基于 Rust By Example

原文链接: https://doc.rust-lang.org/stable/rust-by-example/trait/ops.html

运算符重载

在 Rust 中，很多运算符可以通过 trait 来重载。也就是说，这些运算符可以根据它们的输入参数来完成不同的任务。这之所以可行，是因为运算符就是方法调用的语法糖。例如，a + b 中的 + 运算符会调用 add 方法（也就是 a.add(b)）。这个 add 方法是 Add trait 的一部分。因此，+ 运算符可以被任何 Add trait 的实现者使用。

04-Drop

Thu, 20 Aug 2026 21:20:00 +0800

译文 · 基于 Rust By Example

原文链接: https://doc.rust-lang.org/stable/rust-by-example/trait/drop.html

Drop

Drop trait 只有一个方法：drop，当对象离开作用域时会自动调用该方法。Drop trait 的主要作用是释放实现者的实例拥有的资源。

Box，Vec，String，File，以及 Process 是一些实现了 Drop trait 来释放资源的类型。Drop trait 也可以为任何自定义数据类型手动实现。

05-Iterator

Thu, 20 Aug 2026 21:20:00 +0800

译文 · 基于 Rust By Example

原文链接: https://doc.rust-lang.org/stable/rust-by-example/trait/iter.html

Iterator

Iterator trait 用来对集合（collection）类型（比如数组）实现迭代器。

这个 trait 只需定义一个返回 next（下一个）元素的方法，这可手动在 impl 代码块中定义，或者自动定义（比如在数组或区间中）。

06-`impl Trait`

Thu, 20 Aug 2026 21:20:00 +0800

译文 · 基于 Rust By Example

原文链接: https://doc.rust-lang.org/stable/rust-by-example/trait/impl_trait.html

`impl Trait`

如果函数返回实现了 MyTrait 的类型，可以将其返回类型编写为 -> impl MyTrait。这可以大大简化你的类型签名！

 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


use std::iter;
use std::vec::IntoIter;

// 该函数组合了两个 `Vec <i32>` 并在其上返回一个迭代器。
// 看看它的返回类型多么复杂！
fn combine_vecs_explicit_return_type(
 v: Vec<i32>,
 u: Vec<i32>,
) -> iter::Cycle<iter::Chain<IntoIter<i32>, IntoIter<i32>>> {
 v.into_iter().chain(u.into_iter()).cycle()
}

// 这是完全相同的函数，但其返回类型使用 `impl Trait`。
// 看看它多么简单！
fn combine_vecs(
 v: Vec<i32>,
 u: Vec<i32>,
) -> impl Iterator<Item=i32> {
 v.into_iter().chain(u.into_iter()).cycle()
}

fn main() {
 let v1 = vec![1, 2, 3];
 let v2 = vec![4, 5];
 let mut v3 = combine_vecs(v1, v2);
 assert_eq!(Some(1), v3.next());
 assert_eq!(Some(2), v3.next());
 assert_eq!(Some(3), v3.next());
 assert_eq!(Some(4), v3.next());
 assert_eq!(Some(5), v3.next());
 println!("all done");
}

更重要的是，某些 Rust 类型无法写出。例如，每个闭包都有自己未命名的具体类型。在使用 impl Trait 语法之前，必须在堆上进行分配才能返回闭包。但是现在你可以像下面这样静态地完成所有操作：

07-Clone

Thu, 20 Aug 2026 21:20:00 +0800

译文 · 基于 Rust By Example

原文链接: https://doc.rust-lang.org/stable/rust-by-example/trait/clone.html

Clone

当处理资源时，默认的行为是在赋值或函数调用的同时将它们转移。但是我们有时候也需要把资源复制一份。

Clone trait 正好帮助我们完成这任务。通常，我们可以使用由 Clone trait 定义的 .clone() 方法。

08-父 trait

Thu, 20 Aug 2026 21:20:00 +0800

译文 · 基于 Rust By Example

原文链接: https://doc.rust-lang.org/stable/rust-by-example/trait/supertraits.html

父 trait

Rust 没有“继承”，但是您可以将一个 trait 定义为另一个 trait 的超集（即父 trait）。例如：

 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


trait Person {
 fn name(&self) -> String;
}

// Person 是 Student 的父 trait。
// 实现 Student 需要你也 impl 了 Person。
trait Student: Person {
 fn university(&self) -> String;
}

trait Programmer {
 fn fav_language(&self) -> String;
}

// CompSciStudent (computer science student，计算机科学的学生) 是 Programmer 和 Student 两者的子类。
// 实现 CompSciStudent 需要你同时 impl 了两个父 trait。
trait CompSciStudent: Programmer + Student {
 fn git_username(&self) -> String;
}

fn comp_sci_student_greeting(student: &dyn CompSciStudent) -> String {
 format!(
 "My name is {} and I attend {}. My favorite language is {}. My Git username is {}",
 student.name(),
 student.university(),
 student.fav_language(),
 student.git_username()
 )
}

fn main() {}

参见：

《Rust 程序设计语言》的“父级 trait”章节

09-消除重叠 trait

Thu, 20 Aug 2026 21:20:00 +0800

译文 · 基于 Rust By Example

原文链接: https://doc.rust-lang.org/stable/rust-by-example/trait/disambiguating.html

消除重叠 trait

一个类型可以实现许多不同的 trait。如果两个 trait 都需要相同的名称怎么办？例如，许多 trait 可能拥有名为 get() 的方法。他们甚至可能有不同的返回类型！

第16章 特质 trait on 编程那些事儿

01-派生

派生

参见

02-使用 `dyn` 返回 trait

使用 dyn 返回 trait

03-运算符重载

运算符重载

04-Drop

Drop

05-Iterator

Iterator

06-`impl Trait`

impl Trait

07-Clone

Clone

08-父 trait

父 trait

参见：

09-消除重叠 trait

消除重叠 trait

第16章特质 trait on 编程那些事儿

使用 `dyn` 返回 trait

`impl Trait`