《Rust快速入门》9. 泛型与特性

January 18, 2025

泛型与特性（Traits）：Rust 中的抽象与多态

泛型和特性是 Rust 中实现代码复用和多态性的核心工具。泛型允许我们编写可以处理多种数据类型的函数和数据结构，而特性则定义了类型的行为，使得不同类型的值可以共享相同的接口。本文将详细介绍泛型和特性的定义与使用，并通过完整的代码示例和详尽的指导过程帮助读者深入理解这些概念。

1. 泛型

1.1 泛型函数

泛型函数允许我们编写可以处理多种数据类型的函数。

示例 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 {
        if item > largest {
            largest = item;
        }
    }

    largest
}

fn main() {
    let numbers = vec![34, 50, 25, 100, 65];
    let result = largest(&numbers);
    println!("The largest number is {}", result); // 输出：100

    let chars = vec!['y', 'm', 'a', 'q'];
    let result = largest(&chars);
    println!("The largest char is {}", result); // 输出：y
}

解释：

fn largest<T: PartialOrd>(list: &[T]) -> &T 定义了一个泛型函数 largest，它接受一个 T 类型的切片并返回一个 T 类型的引用。
T: PartialOrd 是泛型约束，表示 T 必须实现 PartialOrd 特性，以便可以使用 > 运算符进行比较。
largest 函数可以处理任何实现了 PartialOrd 特性的类型。

1.2 泛型结构体

泛型结构体允许我们定义可以存储多种数据类型的结构体。

示例 2：定义一个泛型结构体

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


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

    println!("Integer point: ({}, {})", integer_point.x, integer_point.y); // 输出：(5, 10)
    println!("Float point: ({}, {})", float_point.x, float_point.y); // 输出：(1.0, 4.0)
}

解释：

struct Point<T> { ... } 定义了一个泛型结构体 Point，它有两个字段 x 和 y，类型均为 T。
Point 结构体可以用于存储任何类型的值。

1.3 泛型枚举

泛型枚举允许我们定义可以存储多种数据类型的枚举。

示例 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 = Option::Some(5);
    let some_string = Option::Some("hello");

    match some_number {
        Option::Some(value) => println!("Some: {}", value),
        Option::None => println!("None"),
    }

    match some_string {
        Option::Some(value) => println!("Some: {}", value),
        Option::None => println!("None"),
    }
}

解释：

enum Option<T> { ... } 定义了一个泛型枚举 Option，它有两个变体：Some(T) 和 None。
Option 枚举可以用于表示可能为空的值。

2. 特性（Traits）

2.1 定义特性

特性是 Rust 中定义类型行为的抽象接口。通过特性，我们可以为不同类型实现相同的行为。

示例 4：定义一个特性

1
2
3


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

解释：

trait Summary { ... } 定义了一个名为 Summary 的特性。
summarize 是一个方法签名，任何实现 Summary 特性的类型都必须实现这个方法。

2.2 实现特性

我们可以为具体类型实现特性。

示例 5：为结构体实现特性

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


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

fn main() {
    let article = NewsArticle {
        headline: String::from("Penguins win the Stanley Cup Championship!"),
        location: String::from("Pittsburgh, PA, USA"),
        author: String::from("Iceburgh"),
        content: String::from("The Pittsburgh Penguins once again are the best hockey team in the NHL."),
    };

    println!("New article available! {}", article.summarize());
}

解释：

impl Summary for NewsArticle { ... } 为 NewsArticle 结构体实现了 Summary 特性。
summarize 方法返回一个格式化的字符串。

2.3 默认实现

特性方法可以有默认实现。

示例 6：特性方法的默认实现

 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


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

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

impl Summary for Tweet {}

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

    println!("1 new tweet: {}", tweet.summarize()); // 输出：(Read more...)
}

解释：

Summary 特性的 summarize 方法有一个默认实现。
Tweet 结构体没有实现 summarize 方法，因此使用默认实现。

2.4 特性作为参数

特性可以作为函数参数，实现多态性。

示例 7：特性作为参数

 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 article = NewsArticle {
        headline: String::from("Penguins win the Stanley Cup Championship!"),
        location: String::from("Pittsburgh, PA, USA"),
        author: String::from("Iceburgh"),
        content: String::from("The Pittsburgh Penguins once again are the best hockey team in the NHL."),
    };

    notify(&article); // 输出：Breaking news! Penguins win the Stanley Cup Championship!, by Iceburgh (Pittsburgh, PA, USA)
}

解释：

fn notify(item: &impl Summary) 接受任何实现了 Summary 特性的类型的引用。
notify 函数可以处理 NewsArticle、Tweet 等类型。

2.5 特性约束

特性约束允许我们对泛型类型进行更严格的限制。

示例 8：特性约束

1
2
3


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

解释：

fn notify<T: Summary>(item: &T) 使用特性约束 T: Summary，表示 T 必须实现 Summary 特性。

2.6 多重特性约束

我们可以要求泛型类型实现多个特性。

示例 9：多重特性约束

1
2
3


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

解释：

T: Summary + Display 表示 T 必须同时实现 Summary 和 Display 特性。

2.7 特性对象

特性对象允许我们在运行时动态调用实现了特定特性的类型的方法。

示例 10：特性对象

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


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

fn main() {
    let article = NewsArticle {
        headline: String::from("Penguins win the Stanley Cup Championship!"),
        location: String::from("Pittsburgh, PA, USA"),
        author: String::from("Iceburgh"),
        content: String::from("The Pittsburgh Penguins once again are the best hockey team in the NHL."),
    };

    notify(&article); // 输出：Breaking news! Penguins win the Stanley Cup Championship!, by Iceburgh (Pittsburgh, PA, USA)
}

解释：

&dyn Summary 是一个特性对象，它允许在运行时动态调用实现了 Summary 特性的类型的方法。

3. 综合示例

以下是一个综合示例，展示了泛型和特性的结合使用：

 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


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

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

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

fn main() {
    let article = NewsArticle {
        headline: String::from("Penguins win the Stanley Cup Championship!"),
        location: String::from("Pittsburgh, PA, USA"),
        author: String::from("Iceburgh"),
        content: String::from("The Pittsburgh Penguins once again are the best hockey team in the NHL."),
    };

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

    notify(&article); // 输出：Breaking news! Penguins win the Stanley Cup Championship!, by Iceburgh (Pittsburgh, PA, USA)
    notify(&tweet); // 输出：Breaking news! horse_ebooks: of course, as you probably already know, people
}

解释：

该示例展示了如何定义特性、为结构体实现特性、以及使用泛型和特性约束实现多态性。

4. 总结

泛型和特性是 Rust 中实现代码复用和多态性的核心工具。泛型允许我们编写可以处理多种数据类型的函数和数据结构，而特性则定义了类型的行为，使得不同类型的值可以共享相同的接口。掌握这些概念是编写高效、灵活的 Rust 程序的关键。