《深入Rust系统编程》2.5 泛型与trait

2.5 泛型与 trait

泛型和 trait 是 Rust 中用于编写灵活、可重用代码的强大工具。泛型允许开发者编写可以处理多种数据类型的代码，而 trait 则允许开发者定义共享的行为。

2.5.1 泛型

泛型是 Rust 中用于编写可以处理多种数据类型的代码的机制。泛型使用尖括号 (<T>) 表示，其中 T 是类型参数。

1. 泛型函数:

泛型函数可以接受任意类型的参数，并返回任意类型的值：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

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

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

    largest
}

2. 泛型结构体:

泛型结构体可以包含任意类型的字段：

1
2
3
4
5
6
7
8
9

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

fn main() {
    let integer_point = Point { x: 5, y: 10 };
    let float_point = Point { x: 1.0, y: 4.0 };
}

3. 泛型枚举:

泛型枚举可以包含任意类型的变体：

1
2
3
4
5
6
7
8
9

enum Option<T> {
    Some(T),
    None,
}

fn main() {
    let some_number = Some(5);
    let some_string = Some("a string");
}

2.5.2 trait

trait 是 Rust 中用于定义共享行为的机制。trait 类似于其他语言中的接口，但更加强大和灵活。

1. 定义 trait:

trait 使用 trait 关键字定义，其基本语法如下：

1
2
3
4
5

trait TraitName {
    fn method1(&self) -> ReturnType;
    fn method2(&self, param: ParamType) -> ReturnType;
    // ...
}
  • TraitName 是 trait 的名称，遵循 Rust 的命名规范。
  • method1, method2 是 trait 的方法，每个方法都需要指定参数类型和返回类型。

2. 实现 trait:

可以使用 impl 关键字为类型实现 trait：

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

struct StructName {
    // ...
}

impl TraitName for StructName {
    fn method1(&self) -> ReturnType {
        // 方法实现
    }

    fn method2(&self, param: ParamType) -> ReturnType {
        // 方法实现
    }
}

3. 默认方法:

trait 可以定义默认方法，这些方法可以被实现 trait 的类型覆盖：

1
2
3
4
5

trait TraitName {
    fn method1(&self) -> ReturnType {
        // 默认方法实现
    }
}

4. trait 作为参数:

trait 可以作为函数参数，允许函数接受任何实现了该 trait 的类型：

1
2
3

fn function_name(param: impl TraitName) {
    // 函数体
}

5. trait bound:

trait bound 用于指定泛型类型必须实现的 trait：

1
2
3

fn function_name<T: TraitName>(param: T) {
    // 函数体
}

2.5.3 代码实例

1. 泛型函数:

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

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 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);
}

2. 泛型结构体:

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

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

impl<T> Point<T> {
    fn x(&self) -> &T {
        &self.x
    }
}

fn main() {
    let integer_point = Point { x: 5, y: 10 };
    println!("integer_point.x = {}", integer_point.x());

    let float_point = Point { x: 1.0, y: 4.0 };
    println!("float_point.x = {}", float_point.x());
}

3. 泛型枚举:

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

enum Option<T> {
    Some(T),
    None,
}

fn main() {
    let some_number = Some(5);
    let some_string = Some("a string");

    match some_number {
        Some(x) => println!("some_number is {}", x),
        None => println!("some_number is None"),
    }

    match some_string {
        Some(s) => println!("some_string is {}", s),
        None => println!("some_string is None"),
    }
}

4. 定义 trait:

1
2
3

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

5. 实现 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

struct NewsArticle {
    headline: String,
    location: String,
    author: String,
    content: String,
}

impl Summary for NewsArticle {
    fn summarize(&self) -> String {
        format!("{}, by {} ({})", self.headline, self.author, self.location)
    }
}

struct Tweet {
    username: String,
    content: String,
    reply: bool,
    retweet: bool,
}

impl Summary for Tweet {
    fn summarize(&self) -> String {
        format!("{}: {}", self.username, self.content)
    }
}

6. trait 作为参数:

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

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

fn main() {
    let tweet = Tweet {
        username: String::from("horse_ebooks"),
        content: String::from("of course, as you probably already know, people"),
        reply: false,
        retweet: false,
    };

    notify(tweet);
}

7. trait bound:

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

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

fn main() {
    let tweet = Tweet {
        username: String::from("horse_ebooks"),
        content: String::from("of course, as you probably already know, people"),
        reply: false,
        retweet: false,
    };

    notify(tweet);
}

2.5.4 总结

泛型和 trait 是 Rust 中用于编写灵活、可重用代码的强大工具。泛型允许开发者编写可以处理多种数据类型的代码，而 trait 则允许开发者定义共享的行为。掌握泛型和 trait 的使用技巧，可以编写出更通用、更易维护的 Rust 代码。

以下是一些学习 Rust 泛型和 trait 的资源：