深入探讨 Rust 的派生特性

在 Rust 编程语言中，derive 允许编译器为某些特性提供实现。

derive 解决了什么问题？

derive 解决了在手动实现某些特性时编写大量重复代码的问题。它使编译器能够自动生成这些特性的基本实现，从而减少开发者需要编写的代码量。

如何使用 derive？

要使用 derive 属性，只需在类型定义上添加 #[derive(...)]。括号内的 ... 表示应提供基本实现的特性列表。

例如，以下代码片段展示了如何使用 derive 来实现 PartialEq 和 Debug 特性：

#[derive(PartialEq, Debug)]
struct Point {
    x: f64,
    y: f64,
}

fn main() {
    let p1 = Point { x: 1.0, y: 2.0 };
    let p2 = Point { x: 1.0, y: 2.0 };
    assert_eq!(p1, p2);
    println!("{:?}", p1);
}

常见的 derive 属性

常用的特性可以通过 derive 实现，包括比较特性（Eq、PartialEq、Ord、PartialOrd）、克隆特性（Clone）和调试特性（Debug）。这些特性也可以手动实现以实现更复杂的行为。

Eq 和 PartialEq

这两个特性用于比较两个值是否相等。PartialEq 允许部分相等，而 Eq 要求完全相等。

示例：

#[derive(PartialEq, Eq)]
struct Point {
    x: i32,
    y: i32,
}

fn main() {
    let p1 = Point { x: 1, y: 2 };
    let p2 = Point { x: 1, y: 2 };
    assert_eq!(p1, p2);
}

Ord 和 PartialOrd

这两个特性用于比较两个值的顺序。PartialOrd 允许部分排序，而 Ord 要求完全排序。

示例：

#[derive(PartialOrd, Ord)]
struct Point {
    x: i32,
    y: i32,
}

fn main() {
    let p1 = Point { x: 1, y: 2 };
    let p2 = Point { x: 2, y: 1 };
    assert!(p1 < p2);
}

Copy

这个特性用于创建值的副本。它允许从 &T 创建 T 的新实例。

当你将一个变量赋值给另一个变量时，如果类型实现了 Copy 特性，就会创建值的新副本。

要使用 derive 属性生成 Copy ，只需在类型定义前添加 #[derive(Copy)]。例如：

#[derive(Copy)]
struct Point {
    x: i32,
    y: i32,
}

fn main() {
    let p1 = Point { x: 1, y: 2 };
    let p2 = p1;
    assert_eq!(p1.x, p2.x);
    assert_eq!(p1.y, p2.y);
}

需要注意的是，并非所有类型都可以实现 Copy 。例如，包含堆分配字段的类型（如 String 或 Vec<T>）不能实现 Copy。此外，如果一个类型实现了 Drop 特性，它也不能实现 Copy。这是因为当值被释放时，其析构函数会被调用，如果值也实现了 Copy，可能会导致析构函数被多次调用，从而引发未定义行为。

如果你想为在堆上分配资源的类型启用复制功能，应该使用 Clone。

Clone

这个特性用于创建值的副本。它允许从 &T 创建 T 的新实例。

几乎所有的类型都可以实现 Clone 特性。Clone 特性提供了一个 clone 方法，用于创建实例的深拷贝。

与 Copy 特性不同，Clone 不要求按位复制语义。这意味着类型即使有堆分配字段（如 String 或 Vec<T>），它仍然可以实现 Clone。

要为类型自动生成 Clone ，只需在类型定义前添加 #[derive(Clone)]。例如：

#[derive(Clone)]
struct Point {
    x: i32,
    y: i32,
}

fn main() {
    let p1 = Point { x: 1, y: 2 };
    let p2 = p1.clone();
    assert_eq!(p1.x, p2.x);
    assert_eq!(p1.y, p2.y);
}

Debug

这个特性用于生成值的调试字符串表示。

示例：

#[derive(Debug)]
struct Point {
    x: i32,
    y: i32,
}

fn main() {
    let p = Point { x: 1, y: 2 };
    println!("{:?}", p);
}

derive 的缺点和局限性

尽管使用 derive 属性可以快速生成某些特性的基本实现，但它也有一些缺点和局限性。首先，由于编译器自动生成实现，这些实现可能不够复杂。如果你需要更高级的行为，将不得不手动实现这些特性。此外，derive 只能用于某些预定义的特性，并不能适用于所有情况。

原文：www.yuque.com/fengjutian/... 《深入探讨 Rust 的派生特性》