Rust 中的特性（Trait）：从基础到高级

特性（Trait）是什么？

在 Rust 中，特性（Trait）是一种定义共享行为的方式。它允许我们指定一个类型必须实现的方法，从而实现多态和接口抽象。

以下是一个Printable 的特性的示例，其中包含一个名为 print 的方法：

rust 复制代码

trait Printable {
    fn print(&self);
}

定义和实现特性

要定义一个特性，我们使用 trait 关键字，后跟特性名称和一对大括号。在大括号内，我们定义特性包含的方法。

要实现一个特性，我们使用 impl 关键字，后跟特性名称、for 关键字以及我们要实现特性的类型。在大括号内，我们必须为特性中定义的所有方法提供实现。

示例：

rust 复制代码

impl Printable for i32 {
    fn print(&self) {
        println!("{}", self);
    }
}

在这个示例中，我们为 i32 类型实现了 Printable 特性，并为 print 方法提供了一个简单的实现。

特性的继承和组合

Rust 允许我们通过继承和组合来扩展现有的特性。继承使我们在新特性中复用定义的方法，而组合则允许我们使用多个不同的特性。

以下是一个示例，展示如何通过继承来扩展 Printable 特性：

rust 复制代码

trait PrintableWithLabel: Printable {
    fn print_with_label(&self, label: &str) {
        print!("{}: ", label);
        self.print();
    }
}

在这个示例中，我们定义了一个名为 PrintableWithLabel 的新特性，它继承自 Printable 特性。这意味着实现 PrintableWithLabel 的类型也必须实现 Printable。此外，我们提供了一个新的方法 print_with_label，它在打印值之前先打印一个标签。

以下是一个示例，展示如何通过组合来定义一个新特性：

rust 复制代码

trait DisplayAndDebug: std::fmt::Display + std::fmt::Debug {}

在这个示例中，我们定义了一个名为 DisplayAndDebug 的新特性，它由标准库中的两个特性 Display 和 Debug 组成。这意味着实现 DisplayAndDebug 的类型也必须实现 Display 和 Debug。

特性作为参数和返回值

Rust 允许我们将特性作为参数和返回值，从而使我们的代码更具通用性和灵活性。

示例：

rust 复制代码

fn print_twice<T: PrintableWithLabel>(value: T) {
    value.print_with_label("First");
    value.print_with_label("Second");
}

在这个示例中，我们定义了一个名为 print_twice 的函数，它接受一个泛型参数 T。该参数必须实现 PrintableWithLabel 特性。在函数体内，我们对参数调用 print_with_label 方法。

以下是一个示例，展示如何将特性作为返回值使用：

rust 复制代码

fn get_printable() -> impl Printable {
    42
}

然而，fn get_printable() -> impl Printable { 42 } 是不正确的，因为 42 是一个整数，没有实现 Printable 特性。

正确的做法是返回一个实现了 Printable 特性的类型。例如，如果我们为 i32 类型实现了 Printable 特性，我们可以这样写：

rust 复制代码

impl Printable for i32 {
    fn print(&self) {
        println!("{}", self);
    }
}

fn get_printable() -> impl Printable {
    42
}

在这个示例中，我们为 i32 类型实现了 Printable 特性，并为 print 方法提供了一个简单的实现。然后，在 get_printable 函数中，我们返回一个 i32 值 42。由于 i32 类型实现了 Printable 特性，这段代码是正确的。

特性对象和静态分发

在 Rust 中，我们可以通过两种方式实现多态：静态分发 和动态分发。

静态分发是通过泛型实现的。当我们使用泛型参数时，编译器为每种可能的类型生成单独的代码。这使得函数调用在编译时确定。
动态分发 是通过特性对象实现的。当我们使用特性对象时，编译器生成一个通用的代码，可以处理任何实现该特性的类型。这使得函数调用在运行时确定。

以下是一个示例，展示如何使用静态分发和动态分发：

rust 复制代码

fn print_static<T: Printable>(value: T) {
    value.print();
}

fn print_dynamic(value: &dyn Printable) {
    value.print();
}

在这个示例中：

print_static 使用一个泛型参数 T，它必须实现 Printable 特性。当调用此函数时，编译器为传递给它的每种类型生成单独的代码（静态分发）。
print_dynamic 使用一个特性对象（&dyn Printable）作为参数。这启用了动态分发，允许函数处理任何实现 Printable 特性的类型。

关联类型和泛型约束

在 Rust 中，我们可以使用关联类型 和泛型约束来定义更复杂的特性。

关联类型

关联类型允许我们定义一个与特定特性相关的类型。这对于定义依赖于关联类型的方法很有用。

以下是一个使用关联类型定义名为 Add 的特性的示例：

rust 复制代码

trait Add<RHS = Self> {
    type Output;

    fn add(self, rhs: RHS) -> Self::Output;
}

在这个示例中：

我们定义了一个名为 Add 的特性。
它包含一个关联类型 Output，表示 add 方法的返回类型。
RHS 泛型参数指定加法操作的右侧操作数，默认为 Self。

泛型约束

泛型约束允许我们指定泛型参数必须满足的条件（例如，实现特定特性）。

以下是一个在名为 SummableIterator 的特性中使用泛型约束的示例：

rust 复制代码

use std::iter::Sum;

trait SummableIterator: Iterator
where
    Self::Item: Sum,
{
    fn sum(self) -> Self::Item {
        self.fold(Self::Item::zero(), |acc, x| acc + x)
    }
}

在这个示例中：

我们定义了一个扩展标准 Iterator 特性的 SummableIterator 特性。
我们使用一个泛型约束 （where Self::Item: Sum）来指定迭代器的 Item 类型必须实现 Sum 特性。
sum 方法计算迭代器中所有元素的总和。

示例：使用特性实现多态

以下是一个使用 PrintableWithLabel 特性实现多态的示例：

rust 复制代码

struct Circle {
    radius: f64,
}

impl Printable for Circle {
    fn print(&self) {
        println!("Circle with radius {}", self.radius);
    }
}

impl PrintableWithLabel for Circle {}

struct Square {
    side: f64,
}

impl Printable for Square {
    fn print(&self) {
        println!("Square with side {}", self.side);
    }
}

impl PrintableWithLabel for Square {}

fn main() {
    let shapes: Vec<Box<dyn PrintableWithLabel>> = vec![
        Box::new(Circle { radius: 1.0 }),
        Box::new(Square { side: 2.0 }),
    ];

    for shape in shapes {
        shape.print_with_label("Shape");
    }
}

在这个示例中：

我们定义了两个结构体：Circle 和 Square。
这两个结构体都实现了 Printable 和 PrintableWithLabel 特性。
在 main 函数中，我们创建了一个存储特性对象 （Box<dyn PrintableWithLabel>）的向量 shapes。
我们遍历 shapes 向量，并对每个形状调用 print_with_label。

由于 Circle 和 Square 都实现了 PrintableWithLabel，它们可以作为特性对象 存储在向量中。当我们调用 print_with_label 时，编译器会根据对象的实际类型动态确定调用哪个方法。

这就是特性在 Rust 中启用多态的方式。希望本文能帮助你更好地理解特性。

原文：dev.to/leapcell/tr...