Rust 特征(Trait)详解：从基础到实践-优快云博客

本文链接：https://blog.youkuaiyun.com/gitblog_00823/article/details/148393061

Rust 特征(Trait)详解：从基础到实践

rust-by-practice Learning Rust By Practice, narrowing the gap between beginner and skilled-dev through challenging examples, exercises and projects. 项目地址: https://gitcode.com/gh_mirrors/ru/rust-by-practice

特征(Trait)是 Rust 中定义共享行为的重要机制，它允许我们抽象不同类型之间的共性。本文将深入探讨 Rust 特征的概念、用法以及实际应用场景。

什么是特征？

特征可以理解为一种约定，它定义了一组类型必须实现的方法。通过特征，我们可以告诉编译器某个类型具有哪些能力，并且这些能力可以与其他类型共享。

与其它语言的接口(interface)类似，但 Rust 的特征更加灵活和强大：

可以包含默认方法实现
支持关联类型
可以与泛型结合使用
支持特征对象实现动态分发

基础特征实现

让我们从一个简单的例子开始：

struct Sheep { naked: bool, name: String }

trait Animal {
    fn new(name: String) -> Self;
    fn name(&self) -> String;
    fn noise(&self) -> String;
    fn talk(&self) {
        println!("{} says {}", self.name(), self.noise());
    }
}

impl Animal for Sheep {
    fn new(name: String) -> Sheep {
        Sheep { name, naked: false }
    }

    fn name(&self) -> String {
        self.name.clone()
    }

    fn noise(&self) -> String {
        if self.naked { "baaaaah?" } else { "baaaaah!" }.to_string()
    }
    
    fn talk(&self) {
        println!("{} pauses briefly... {}", self.name, self.noise());
    }
}

在这个例子中，我们定义了一个 Animal 特征，并为 Sheep 结构体实现了这个特征。注意我们重写了默认的 talk 方法实现。

特征约束与泛型

特征可以与泛型结合使用，对泛型类型进行约束：

fn sum<T: std::ops::Add<Output = T>>(x: T, y: T) -> T {
    x + y
}

这里我们要求类型 T 必须实现 std::ops::Add 特征，这样才能使用 + 运算符。

运算符重载

Rust 中的运算符实际上是特征方法的语法糖。例如 + 对应 std::ops::Add 特征：

use std::ops;

struct Foo;
struct Bar;
struct FooBar;

impl ops::Add<Bar> for Foo {
    type Output = FooBar;
    fn add(self, _rhs: Bar) -> FooBar {
        FooBar
    }
}

特征作为参数和返回值

我们可以使用特征作为函数参数或返回值：

// 作为参数
fn summary(item: impl Summary) {
    println!("Summary: {}", item.summarize());
}

// 作为返回值
fn random_animal(random_number: f64) -> impl Animal {
    if random_number < 0.5 { Sheep {} } else { Cow {} }
}

派生特征

Rust 提供了一些可以通过 #[derive] 属性自动派生的特征：

#[derive(Debug, PartialEq, PartialOrd)]
struct Centimeters(f64);

常见的可派生特征包括：Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord 等。

实践练习

让我们通过几个练习来巩固对特征的理解：

实现 Hello 特征：

trait Hello {
    fn say_hi(&self) -> String {
        String::from("hi")
    }
    fn say_something(&self) -> String;
}

impl Hello for Student {
    fn say_something(&self) -> String {
        "I'm a good student".to_string()
    }
}

实现缓存器模式：

struct Cacher<T: Fn(u32) -> u32> {
    calculation: T,
    value: Option<u32>,
}

impl<T: Fn(u32) -> u32> Cacher<T> {
    fn new(calculation: T) -> Self {
        Cacher { calculation, value: None }
    }
    
    fn value(&mut self, arg: u32) -> u32 {
        match self.value {
            Some(v) => v,
            None => {
                let v = (self.calculation)(arg);
                self.value = Some(v);
                v
            }
        }
    }
}