Rust系统编程之泛型

1.泛型基础

与C++中的模板很像。

1.1 函数中的泛型

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

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

此时这段代码还不能编译，因为 largest 的函数体不能适用于 T 的所有可能的类型，标准库中定义的 std::cmp::PartialOrd trait 可以实现类型的比较功能。

1.2 结构体中的泛型

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

fn main() {
    let both_integer = Point { x: 5, y: 10 };
    let both_float = Point { x: 1.0, y: 4.0 };
    let integer_and_float = Point { x: 5, y: 4.0 };
}

1.3 枚举中的泛型

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

enum Result<T, E> {
    Ok(T),
    Err(E),
}

1.4 成员函数中的泛型

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

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

impl Point<f32> {
    fn distance_from_origin(&self) -> f32 {
        (self.x.powi(2) + self.y.powi(2)).sqrt()
    }
}

fn main() {
    let p = Point { x: 5, y: 10 };

    println!("p.x = {}", p.x());
}

distance_from_origin方法是只有类型为f32的对象才可以调用。

2.Trait

trait就是其他语言中的抽象接口。

2.1 定义一个Trait

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

2.2 实现一个Trait

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

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

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

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

孤儿规则：只有当至少一个 trait 或者要实现 trait 的类型位于 crate 的本地作用域时，才能为该类型实现 trait。

默认实现

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

可以在声明Trait时给一个默认的函数实现，如果想要对 NewsArticle 实例使用这个默认实现，可以通过 impl Summary for NewsArticle {} 指定一个空的 impl 块。

调用兄弟方法

Trait中可以调用其他方法，即使那个方法没有默认实现。

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

    fn summarize(&self) -> String {
        format!("(Read more from {}...)", self.summarize_author())
    }
}

2.3 Trait作为函数参数

2.3.1 普通函数

限制泛型类型，只有实现了Summary和Display的类型才可以作为参数。

pub fn notify(item: &(impl Summary + Display)) { }

pub fn notify<T: Summary + Display>(item: &T) { }

2.3.2 成员函数

只有实现了标准库中定义的 std::cmp::PartialOrd trait的类型才可以调用这个函数。

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

2.4 Trait作为返回值类型

fn returns_summarizable() -> impl Summary {
    Tweet {
        username: String::from("horse_ebooks"),
        content: String::from(
            "of course, as you probably already know, people",
        ),
        reply: false,
        retweet: false,
    }
}

2.5 blanket implementations

在实现Trait的类型上再加入一层过滤，只有实现了某个Trait的类型才能实现我这个Tarit。

impl<T: Display> ToString for T {
    // --snip--
}

例子：

pub trait TestMessage {
    fn func1(&self) -> String;
}

pub trait TestMessage2 {
    fn func2(&self);
}

pub trait TestMessage3 {
    fn func3(&self);
}

struct MyStru {
    name: String,
    age: u64,
}

impl TestMessage for MyStru {
    fn func1(&self) -> String {
        "".to_string()
    }
}

// 如果这个未实现，m.fun3()不合法
impl TestMessage2 for MyStru {
    fn func2(&self) {}
}

// 这里表示为所有实现了TestMessage2 trait的结构体实现TestMessage3 trait
impl<T: TestMessage2> TestMessage3 for T {
    fn func3(&self) {}
}

fn main() {
    let m = MyStru{name: "hello".to_string(), age: 1};
    m.func3();		// 合法
}