Rust on Jack Jiang'Blog

Rust学习之路——深入了解特征

Mon, 01 Apr 2024 22:33:18 +0800

关联类型

关联类型时在特征定义的语句块中，申明一个自定义类型，这样就可以在特征的方法签名中使用该类型。

1
2
3
4
5


pub trait Iterator {
 type Item;

 fn next(&mut self) -> Option<Self::Item>;
}

Self用来指代当前调用者的具体类型，那么Self::Item就用来指代该类型实现中定义的Item类型：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


impl Iterator for Counter {
 type Item = u32;

 fn next(&mut self) -> Option<Self::Item> {
 //...
 }
}

fn main() {
 let c = Counter{..}
 c.next()
}

上述代码中，Counter类型实现了Iterator特征，变量c是特征Iterator的实例，也是next方法的调用者。

为什么不使用泛型:

1
2
3


pub trait Iterator<Item>{
 fn next(&mut self) -> Option<Item>;
}

因为代码的可读性

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


// 泛型写法
trait Container<A,B> {
 fn contains(&self,a: A,b: B) ->bool;
}

fn difference<A,B,C(container:&C) -> i32
 where
 c: Container<A,B> {...}

// 关联类型实现
trait Container{
 type A;
 type B;
 fn copntains(&self, a:Self::A,b:&Self::B) -> bool;
}

fn differnce<C: Container>(container:&:C) {}

默认泛型类型参数

在外部类型上实现外部特征（newtype）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


use std::fmt;

struct Wrapper(Vec<String>);

impl fmt::Display for Wrapper {
 fn fmt(&self, f:&mut fmt::Formatter) -> fmt::Result {
 write!(f, "[{}]", self.0.join(", "))
 }
}

fn main() {
 let w = Wrapper(vec![String::from("hello"), String::from("world")]);
 println!("w = {}", w);
}

Rust学习之路——特征对象

Mon, 25 Mar 2024 22:42:09 +0800

在上一节中有一段代码无法通过边缘：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


fn returns_summarizable(switch: bool) -> impl Summary {
 if switch {
 Post {
 // ...
 }
 } else {
 Weibo {
 // ...
 }
 }
}

其中Post和Weibo都实现了Summary 特征，因此上面的函数试图通过返回 impl Summary 来返回这两个类型，但是编译器却无情地报错了，原因是 impl Trait 的返回值类型并不支持多种不同的类型返回，那如果我们想返回多种类型，该怎么办？

再来考虑一个问题：现在在做一款游戏，需要将多个对象渲染在屏幕上，这些对象属于不同的类型，存储在列表中，渲染的时候，需要循环该列表并顺序渲染每个对象，在 Rust 中该怎么实现？

使用枚举

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


#[derive(Debug)]
enum UiObject {
 Button,
 SelectBox,
}

fn main() {
 let object = [
 UiObject::Button,
 UiObject::SelectBox
 ];

 for o in object {
 draw(o)
 }
}

fn draw(o: UiObject) {
 println!("{:?}", o);
}

问题，如果对象集合并不能事先明确的知道？缺失或想要新增枚举类型？

我们无法知道所有的UI对象类型，只是知道：

UI对象的类型不同
需要一个统一的类型来处理这些对象，无论是作为函数参数还是作为列表中的一员
需要对每个对象调用draw方法

在拥有继承的语言中，可定义一个名为Component的类，该类上有一个draw方法。其他的类比如Button、Image和SelectBox会从Component派生并因此继承draw方法。它们各自都可以覆盖draw方法来定义自己的行为，但是框架会把所有这些类型当作是Component的实例，并在其上调用draw。不过Rust并没有继承。

特征对象定义

为了解决上面的所有问题，Rust引入了一个概念–特征对象。先定义一个特征

1
2
3


pub trait Draw {
 fn draw(&self);
}

只要实现了Draw特征，就可以调用draw方法来进行渲染。假设有个Button和SelectBox组件实现了Draw特征：

 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


pub struct Button {
 pub width: u32,
 pub height: u32,
 pub label: String,
}

impl Draw for Button {
 fn draw(&self) {
 // 绘制按钮代码
 }
}

struct SelectBox {
 width: u32,
 height: u32,
 options: Vec<String>,
}

impl Draw for SelectBox {
 fn draw(&self) {
 // 绘制SelectBox的代码
 }
}

//需要一个动态数组来存储这些UI对象
pub struct Screen {
 pub components: Vec<?>
}

代码中的?: 可以替换为Draw的特征对象，通过&引用或者Box<T>智能指针的方式来创建特征对象。

tips: Box<T>包裹的值会被强制分配在堆上

 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


trait Draw {
 fn draw(&self)->String;
}

impl Draw for u8 {
 fn draw(&self) -> String {
 format!("u8: {}", *self)
 }
}

impl Draw for f64 {
 fn draw(&self) -> String {
 format!("f64: {}", *self)
 }
}

// 若 T 实现了Draw特征，则调用该函数时传入的Box<T>可以被隐式转换成函数参数签名中的Box<dyn Draw>
fn draw1(x: Box<dyn Draw>) {
 // 由于实现了 Deref特征，Box智能指针会自动解引用为它所包裹的值，然后调用该值对应的类型上定义的`draw`方法
 x.draw();
}

fn draw2(x: &dyn Draw) {
 x.draw();
}

fn main {
 let x = 1.1f64;
 let y = 8u8;

 // x和y的类型T都实现了`Draw`特征，因为Box<T>可以在函数调用时隐式地被转换为特征对象 Box<dyn Draw>
 // 基于x的值创建一个Box<f64>类型的智能指针，指针指向的数据被放置在了堆上
 draw1(Box::new(x));
 // 基于 y 的值创建一个 Box<u8> 类型的智能指针
 draw1(Box::new(y));
 draw2(&x);
 draw2(&y);
}

draw1 函数的参数是 Box<dyn Draw> 形式的特征对象，该特征对象是通过 Box::new(x) 的方式创建的
draw2 函数的参数是 &dyn Draw形式的特征对象，该特征对象是通过 &x 的方式创建的
dyn 关键字只用在特征对象的类型声明上，在创建时无需使用 dyn

因此，可以使用特征对象来代表泛型或具体的类型。

1
2
3


pub struct Screen {
 pub components: Vec<Box<dyn Draw>>,
}

其中存储了一个动态数组，里面元素的类型是 Draw 特征对象：Box<dyn Draw>，任何实现了 Draw 特征的类型，都可以存放其中。

再来为 Screen 定义 run 方法，用于将列表中的 UI 组件渲染在屏幕上：

1
2
3
4
5
6
7


impl Screen {
 pub fn run(&self) {
 for component in self.components.iter() {
 component.draw();
 }
 }
}

在列表中存储多种不同类型的实例，然后将它们使用同一个方法逐一渲染在屏幕上！

泛型实现:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


pub struct Screen<T: Draw> {
 pub components: Vec<T>,
}

impl<T> Screen<T>
 where T: Draw {
 pub fn run(&self) {
 for component in self.components.iter() {
 component.draw();
 }
 }
}

上面的Screen的列表中，存储了类型为T的元素，然后在Screen中使用特征约束让T实现了Draw特征，进而可以调用draw方法。

这种写法限制了Screen实例的Vec<T>中每个元素必须时Button类型或者全是SelectBox类型。如果只需要相同类型集合，更倾向于采用泛型+特征约束这种写法，因为这样实现更清晰，性能更好。（特征对象需要在运行时从vtable动态查找需要调用的方法）

运行

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


fn main() {
 let screen =Screen {
 components: vec![
 Box::new(SelectBox{
 width:75,
 height:10,
 options:vec![
 String::from("Yes"),
 String::from("Maybe"),
 String::from("No")
 ],
 }),
 Box::new(Button {
 width: 50,
 height: 10,
 label: String::from("OK",)
 }),
 ],
 };

 screen.run();
}

上面使用 Box::new(T) 的方式来创建了两个 Box<dyn Draw> 特征对象，如果以后还需要增加一个 UI 组件，那么让该组件实现 Draw 特征，则可以很轻松的将其渲染在屏幕上，甚至用户可以引入我们的库作为三方库，然后在自己的库中为自己的类型实现 Draw 特征，然后进行渲染。

在动态类型语言中，有一个很重要的概念： 鸭子类型（duck typing），简单来说，就是只关心值长啥样，而不关心它实际是什么。当一个东西走起来像鸭子，叫起来像鸭子，那么它就是一只鸭子，就算它实际上是一个奥特曼，也不重要，我们就当它是鸭子。

使用特征对象和Rust类型系统来进行类似鸭子类型操作的优势是，无需在运行时检查一个值是否实现了特定方法或者担心在调用时因为值没有实现方法而产生错误。如果值没有实现特征对象所需的特征，那么Rust根本就不会编译这些代码。

1
2
3
4
5
6
7


fn main() {
 let screen = Screen {
 components: vec!{
 Box::new(String::from("Hi")),
 },
 };
}

因为String类型没有实现Draw特征，编译器直接就会报错，不会让上述代码运行。如果想要String类型被渲染在屏幕上，只需要为其实现Draw特征即可。

注意dyn不能单独作为特征对象的定义。特征对象可以是任意实现了每个特征的类型，编译器在编译期间不知道该类型的大小。不同类型的大小是不同的。

&dyn 和 Box 在编译期都是已知大小。

1
2
3
4
5
6
7
8
9


fn draw2(x: dyn Draw) {
 x.draw();
}

10 | fn draw2(x: dyn Draw) {
 | ^ doesn't have a size known at compile-time
 |
 = help: the trait `Sized` is not implemented for `(dyn Draw + 'static)`
help: function arguments must have a statically known size, borrowed types always have a known size

特征对象的动态分发

泛型是在编译期完成处理的：编译器会为每一个泛型参数对应的具体类型生成一份代码，这种方式是静态分发(static dispatch)，因为是在编译期完成的，对于运行期性能完全没有任何影响。

与静态分发相对应的是动态分发(dynamic dispatch)，在这种情况下，直到运行时，才能确定需要调用什么方法。之前代码中的关键字 dyn 正是在强调这一“动态”的特点。

当使用特征对象时，Rust 必须使用动态分发。编译器无法知晓所有可能用于特征对象代码的类型，所以它也不知道应该调用哪个类型的哪个方法实现。为此，Rust 在运行时使用特征对象中的指针来知晓需要调用哪个方法。动态分发也阻止编译器有选择的内联方法代码，这会相应的禁用一些优化。

下面这张图很好的解释了静态分发 Box 和动态分发 Box 的区别：

特征对象大小不固定：这是因为，对于特征 Draw，类型 Button 可以实现特征 Draw，类型 SelectBox 也可以实现特征 Draw，因此特征没有固定大小
几乎总是使用特征对象的引用方式，如 &dyn Draw、Box<dyn Draw>
- 虽然特征对象没有固定大小，但它的引用类型的大小是固定的，它由两个指针组成（ptr 和 vptr），因此占用两个指针大小
- 一个指针 ptr 指向实现了特征 Draw 的具体类型的实例，也就是当作特征 Draw 来用的类型的实例，比如类型 Button 的实例、类型 SelectBox 的实例
- 另一个指针 vptr 指向一个虚表 vtable，vtable 中保存了类型 Button 或类型 SelectBox 的实例对于可以调用的实现于特征 Draw 的方法。当调用方法时，直接从 vtable 中找到方法并调用。之所以要使用一个 vtable 来保存各实例的方法，是因为实现了特征 Draw 的类型有多种，这些类型拥有的方法各不相同，当将这些类型的实例都当作特征 Draw 来使用时(此时，它们全都看作是特征 Draw 类型的实例)，有必要区分这些实例各自有哪些方法可调用

简而言之，当类型 Button 实现了特征 Draw 时，类型 Button 的实例对象 btn 可以当作特征 Draw 的特征对象类型来使用，btn 中保存了作为特征对象的数据指针（指向类型 Button 的实例数据）和行为指针（指向 vtable）。

一定要注意，此时的 btn 是 Draw 的特征对象的实例，而不再是具体类型 Button 的实例，而且 btn 的 vtable 只包含了实现自特征 Draw 的那些方法（比如 draw），因此 btn 只能调用实现于特征 Draw 的 draw 方法，而不能调用类型 Button 本身实现的方法和类型 Button 实现于其他特征的方法。也就是说，btn 是哪个特征对象的实例，它的 vtable 中就包含了该特征的方法。

Self 与 self

在Rust中,有两个self，一个指代当前的实例对象，一个指代特征或方法类型的别名。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


trait Draw {
 fn draw(&self) -> Self;
}

#[derive(Clone)]
struct Button;
impl Draw for Button {
 fn draw(&self) -> Self {
 return self.clone()
 }
}

Rust学习之路——特征（Trait）

Mon, 11 Mar 2024 22:36:29 +0800

—— 本文内容从《Rust语言圣经（Rust Course）》中归纳

特征 Trait

1
2
3
4



fn add<T: std::ops::Add<Output = T>>(a:T, b:T) -> T {
 a + b
}

Trait 定义了一组可以被共享的行为，只要实现了特征，你就能实现这组行为。

定义 Trait

定义特征是把一些方法组合在一起，目的是定义一个实现某些目标所必需的行为的合集。

1
2
3
4



pub trait Summary {
 fn summarize(&self) -> String;
}

这里使用trait关键字来声明一个特征，Summary是特证名。在大括号中定义了该特征的所有方法。
特征只定义行为看起来是什么样的，而不定义行为具体是什么样的。
实现这个特征的类型都需要具体实现该特征的相应方法。

为类型实现特征

特征只定义行为，需要为类型实现具体的特征，定义具体行为。

 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



pub trait Summary {
 fn summarize(&self) -> String;
}
pub struct Post {
 pub title: String, // 标题
 pub author: String, // 作者
 pub content: String, // 内容
}

impl Summary for Post {
 fn summarize(&self) -> String {
 format!("文章{}, 作者是{}", self.title, self.author)
 }
}

pub struct Weibo {
 pub username: String,
 pub content: String
}

impl Summary for Weibo {
 fn summarize(&self) -> String {
 format!("{}发表了微博{}", self.username, self.content)
 }
}

fn main() {
 let post = Post{title: "Rust语言简介".to_string(),author: "Sunface".to_string(), content: "Rust棒极了!".to_string()};
 let weibo = Weibo{username: "sunface".to_string(),content: "好像微博没Tweet好用".to_string()};

 println!("{}",post.summarize());
 println!("{}",weibo.summarize());
}

特征定义与实现的位置（孤儿规则）

！！重要原则（孤儿原则） 若为类型A实现特征T，则A或T至少有一个需要时在当前作用域中定义的

这可以确保他人编写的代码不会破坏你的代码

默认实现

默认实现不要求重载Trait内的方法

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


pub trait Summary {
 fn summarize(&self) -> String {
 String::from("(Read more...)")
 }
}

impl Summary for Post {}

impl Summary for Weibo {
 fn summarize(&self) -> String {
 format!("{}发表了微博{}", self.username, self.content)
 }
}

// Summary for Post: (Read more...)
// Summary for Weibo :sunface发表了微博好像微博没Tweet好用

默认实现可以调用相同特征中的其他方法，哪怕这些方法没有默认实现

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


// 定义
pub trait Summary {
 fn summarize_author(&self) -> String;

 fn summarize(&self) -> String {
 format!("(Read more from {}...)", self.summarize_author())
 }
}
//调用
impl Summary for Weibo {
 fn summarize_author(&self) -> String {
 format!("@{}", self.username)
 }
}
println!("1 new weibo: {}", weibo.summarize());

使用特征作为函数参数

特征作为函数参数

1
2
3


pb fun notify(item: &impl Summary) {
 println!("Breaking news! {}", item.summarize());
}

impl Summary,顾名思义，指实现了Summary特征的item参数。

特征约束（trait bound）

impl [Trait Name] 实际上是一个语法糖，完整形式是：

1
2
3


pub fn notify<T: Summary>(item: &T){
 println!("Breaking news!", item.summarize());
}

完整的书写形式：T: [Trait Name]，被称为特征约束。

impl [Trait Name] 适用于简单场景，

1

pub fn notify(item1: &impl Summary, item2: &impl Summary) {}

T: [Trait Name]可以进一步约束参数必须类型相同

1

pub fn notify<T:Summary>(item: &T, item2: &T){}

多重约束

1
2
3
4
5


// 语法糖
pub fn notify(item: &(impl Summary + Display)) {}

// 特征约束
pub fn notify<T: Summary + Display>(item: &T) {}

Where 约束

1
2
3
4
5
6
7
8


// 特征约束变多，签名变得复杂
fn some_function<T: Display + Clone, U: Clone + Debug>(t: &T, u: &U) -> i32 {}

// 通过where 简化
fn some_fucntion<T, U>(t: &T, u: &U) -> i32
 where T: Display + Clone,
 U: Clone + Debug
{}

使用特征约束有条件地实现方法或特征

指定类型 + 指定特征的条件下去实现方法

 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


use std::fmt::Display;

struct Pair<T>{
 x:T,
 y:T,
}

impl<T> Pair<T>{
 fn new(x:T, y:Y) -> Self {
 Self {
 x,
 y,
 }
 }
}

// 只有T同时实现了Display + PartialOrd得Pair<T>才有cmp_display方法
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);
 }
 }
}

有条件地实现特征

标准库为任何实现Display特征的类型实现了ToString特征：

1
2
3
4
5
6
7


impl<T: Display> ToString for T {
 //...
}

//任何实现了Display的特征的类型调用由ToString定义的to_string方法。

let s = 3.to_string();

函数中返回 impl Trait

可以通过impl Trait来说明一个函数返回了实习了指定Trait的类型

1
2
3
4
5
6
7
8


fn returns_summarizable() -> impl Summary {
 Weibo {
 username: String::from("sunface"),
 content: String::from(
 "m1 max太厉害了，电脑再也不会卡",
 )
 }
}

注意，这里只能让函数调用者知道，函数的返回值实现了Summary这个Trait，却没有告知调用者，返回值的具体类型。这种写法在返回类型特别复杂，无法明确定义的情况下特别有用，但是要注意的是： 返回值只能是一种具体类型，例如

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


fn returns_summarizable(switch: bool) -> impl Summary {
 if switch {
 Post {
 title: String::from (
 "Penguins win the Stanley Cup Championship!",
 ),
 author: String::from("Iceburgh"),
 content: String::from(
 "The Pittsburgh Penguins once again are then best
 hockey team in the NHL.",
 )
 }
 } else {
 Weibo {
 username: String::from("horse_ebooks"),
 content: String::from(
 "of course,as you probaly alread knoew,people",
 )
 }
 }
}

以上代码无法通过编译，因为返回了不同的类型。如果想实现返回不同的类型，需要使用下一章节中的特征对象

修复上一节中largest函数

上一节例子中编译报错问题 // todo

 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


fn largest<T>(list: &[T]) -> T {
 let mut largest = list[0];

 fro &item in list.iter() {
 if item > largest {
 largest = item;
 }
 }
 largest
}

fn main() {
 let number =_list =vec![34, 58, ]
}


error[E0369]: binary operation `>` cannot be applied to type `T` // 无法在 `T` 类型上应用`>`运算符
 --> src/main.rs:5:17
 |
5 | if item > largest {
 | ---- ^ ------- T
 | |
 | T
 |
help: consider restricting type parameter `T` // 考虑使用以下的特征来约束 `T`
 |
1 | fn largest<T: std::cmp::PartialOrd>(list: &[T]) -> T {
 | ^^^^^^^^^^^^^^^^^^^^^^

在 largest 函数体中我们想要使用大于运算符（>）比较两个 T 类型的值。这个运算符是标准库中特征 std::cmp::PartialOrd 的一个默认方法。

1

fn largest<T: PartialOrd>(list: &[T]) -> T {}

会出现新的错误：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


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
 | help: consider using a reference instead: `&list[0]`

error[E0507]: cannot move out of borrowed content
 --> src/main.rs:4:9
 |
4 | for &item in list.iter() {
 | ^----
 | ||
 | |hint: to prevent move, use `ref item` or `ref mut item`
 | cannot move out of borrowed content

错误的核心是 cannot move out of type [T], a non-copy slice，原因是 T 没有实现 Copy 特性，因此我们只能把所有权进行转移，毕竟只有 i32 等基础类型才实现了 Copy 特性，可以存储在栈上，而 T 可以指代任何类型（严格来说是实现了 PartialOrd 特征的所有类型）。

因此，为了让 T 拥有 Copy 特性，我们可以增加特征约束：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


fn largest<T: PartialOrd + Copy>(list: &[T]) -> T {
 let mut largest = list[0];

 for &item in list.iter() {
 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);
}

通过derive派生特征

在本书中，形如#[derive(Debug)]的代码，这种是一种特征派生语法，被 derive 标记的对象会自动实现对应的默认特征代码，继承相应的功能。

Debug 特征，它有一套自动实现的默认代码，当你给一个结构体标记后，就可以使用 println!("{:?}", s) 的形式打印该结构体的对象。

Copy 特征，它也有一套自动实现的默认代码，当标记到一个类型上时，可以让这个类型自动实现 Copy 特征，进而可以调用 copy 方法，进行自我复制。

derive 派生出来的是 Rust 默认给我们提供的特征，在开发过程中极大的简化了自己手动实现相应特征的需求。

用于开发者输出的 Debug

Debug 特征可以让指定对象输出调试格式的字符串，通过在 {} 占位符中增加 :? 表明，例如println!(“show you some debug info: {:?}”, MyObject);.

Debug 特征允许以调试为目的来打印一个类型的实例，所以程序员可以在执行过程中看到该实例的具体信息。

例如，在使用 assert_eq! 宏时， Debug 特征是必须的。如果断言失败，这个宏就把给定实例的值打印出来，这样程序员就能看到两个实例为什么不相等。

等值比较的 PartialEq 和 Eq

PartialEq 特征可以比较一个类型的实例以检查是否相等，并开启了 == 和 != 运算符的功能。

派生的 PartialEq 实现了 eq 方法。当 PartialEq 在结构体上派生时，只有所有的字段都相等时两个实例才相等，同时只要有任何字段不相等则两个实例就不相等。当在枚举上派生时，每一个成员都和其自身相等，且和其他成员都不相等。

例如，当使用 assert_eq! 宏时，需要比较一个类型的两个实例是否相等，则 PartialEq 特征是必须的。

Eq 特征没有方法, 其作用是表明每一个被标记类型的值都等于其自身。 Eq 特征只能应用于那些实现了 PartialEq 的类型，但并非所有实现了 PartialEq 的类型都可以实现 Eq。浮点类型就是一个例子：浮点数的实现表明两个非数字（ NaN ，not-a-number）值是互不相等的。

例如，对于一个 HashMap<K, V> 中的 key 来说， Eq 是必须的，这样 HashMap<K, V> 就可以知道两个 key 是否一样。

次序比较的 PartialOrd 和 Ord

Clone 特征用于创建一个值的深拷贝（deep copy），复制过程可能包含代码的执行以及堆上数据的复制。查阅通过 Clone 进行深拷贝获取有关 Clone 的更多信息。

派生 Clone 实现了 clone 方法，当为整个的类型实现 Clone 时，在该类型的每一部分上都会调用 clone 方法。这意味着类型中所有字段或值也必须实现了 Clone，这样才能够派生 Clone 。

例如，当在一个切片（slice）上调用 to_vec 方法时， Clone 是必须的。切片只是一个引用，并不拥有其所包含的实例数据，但是从 to_vec 中返回的 Vector 需要拥有实例数据，因此， to_vec 需要在每个元素上调用 clone 来逐个复制。因此，存储在切片中的类型必须实现 Clone。

Copy 特征允许你通过只拷贝存储在栈上的数据来复制值(浅拷贝),而无需复制存储在堆上的底层数据。查阅通过 Copy 复制栈数据的部分来获取有关 Copy 的更多信息。

实际上 Copy 特征并不阻止你在实现时使用了深拷贝，只是，我们不应该这么做，毕竟遵循一个语言的惯例是很重要的。当用户看到 Copy 时，潜意识就应该知道这是浅拷贝，复制一个值会非常快。

当一个类型的内部字段全部实现了 Copy 时，你就可以在该类型上派上 Copy 特征。一个类型如果要实现 Copy 它必须先实现 Clone ，因为一个类型实现 Clone 后，就等于顺便实现了 Copy 。

总之， Copy 拥有更好的性能，当浅拷贝足够的时候，就不要使用 Clone ，不然会导致你的代码运行更慢，对于性能优化来说，一个很大的方面就是减少热点路径深拷贝的发生。

固定大小的值映射的 Hash

Hash 特征允许你使用 hash 函数把一个任意大小的实例映射到一个固定大小的值上。派生 Hash 实现了 hash 方法，对某个类型进行 hash 调用，其实就是对该类型下每个字段单独进行 hash 调用，然后把结果进行汇总，这意味着该类型下的所有的字段也必须实现了 Hash，这样才能够派生 Hash。

例如，在 HashMap<K, V> 上存储数据，存放 key 的时候， Hash 是必须的。

默认的Default

Default 特征会帮你创建一个类型的默认值。派生 Default 意味着自动实现了 default 函数。 default 函数的派生实现调用了类型每部分的 default 函数，这意味着类型中所有的字段也必须实现了 Default，这样才能够派生 Default 。

Default::default 函数通常结合结构体更新语法一起使用，这在第五章的结构体更新语法部分有讨论。可以自定义一个结构体的一小部分字段而剩余字段则使用 ..Default::default() 设置为默认值。

例如，当你在 Option 实例上使用 unwrap_or_default 方法时， Default 特征是必须的。如果 Option 是 None 的话, unwrap_or_default 方法将返回 T 类型的 Default::default 的结果。

调用方法需要引入特征

在一些场景中，使用 as 关键字做类型转换会有比较大的限制，因为你想要在类型转换上拥有完全的控制，例如处理转换错误，那么你将需要 TryInto：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


use std::convert::TryInto;

fn main() {
 let a: i32 = 10;
 let b: u16 = 100;

 let b_ = b.try_into()
 .unwrap();

 if a < b_ {
 println!("Ten is less than one hundred.");
 }
}

上面代码中引入了 std::convert::TryInto 特征，但是却没有使用它，可能有些同学会为此困惑，主要原因在于如果你要使用一个特征的方法，那么你需要将该特征引入当前的作用域中，我们在上面用到了 try_into 方法，因此需要引入对应的特征。

但是 Rust 又提供了一个非常便利的办法，即把最常用的标准库中的特征通过 std::prelude 模块提前引入到当前作用域中，其中包括了 std::convert::TryInto，你可以尝试删除第一行的代码 use …，看看是否会报错。

几个综合例子

为自定义类型实现 + 操作

在 Rust 中除了数值类型的加法，String 也可以做加法，因为 Rust 为该类型实现了 std::ops::Add 特征，同理，如果我们为自定义类型实现了该特征，那就可以自己实现 Point1 + Point2 的操作:

 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


use std::ops::Add;

// 为Point结构体派生Debug特征，用于格式化输出
#[derive(Debug)]
struct Point<T: Add<T, Output = T>> { //限制类型T必须实现了Add特征，否则无法进行+操作。
 x: T,
 y: T,
}

impl<T: Add<T, Output = T>> Add for Point<T> {
 type Output = Point<T>;

 fn add(self, p: Point<T>) -> Point<T> {
 Point{
 x: self.x + p.x,
 y: self.y + p.y,
 }
 }
}

fn add<T: Add<T, Output=T>>(a:T, b:T) -> T {
 a + b
}

fn main() {
 let p1 = Point{x: 1.1f32, y: 1.1f32};
 let p2 = Point{x: 2.1f32, y: 2.1f32};
 println!("{:?}", add(p1, p2));

 let p3 = Point{x: 1i32, y: 1i32};
 let p4 = Point{x: 2i32, y: 2i32};
 println!("{:?}", add(p3, p4));
}

自定义类型的打印输出

在开发过程中，往往只要使用 #[derive(Debug)] 对我们的自定义类型进行标注，即可实现打印输出的功能：

1
2
3
4
5
6
7
8
9


#[derive(Debug)]
struct Point{
 x: i32,
 y: i32
}
fn main() {
 let p = Point{x:3,y:3};
 println!("{:?}",p);
}

但是在实际项目中，往往需要对我们的自定义类型进行自定义的格式化输出，以让用户更好的阅读理解我们的类型，此时就要为自定义类型实现 std::fmt::Display 特征：

 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


#![allow(dead_code)]

use std::fmt;
use std::fmt::{Display};

#[derive(Debug,PartialEq)]
enum FileState {
 Open,
 Closed,
}

#[derive(Debug)]
struct File {
 name: String,
 data: Vec<u8>,
 state: FileState,
}

impl Display for FileState {
 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
 match *self {
 FileState::Open => write!(f, "OPEN"),
 FileState::Closed => write!(f, "CLOSED"),
 }
 }
}

impl Display for File {
 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
 write!(f, "<{} ({})>",
 self.name, self.state)
 }
}

impl File {
 fn new(name: &str) -> File {
 File {
 name: String::from(name),
 data: Vec::new(),
 state: FileState::Closed,
 }
 }
}

fn main() {
 let f6 = File::new("f6.txt");
 //...
 println!("{:?}", f6);
 println!("{}", f6);
}