Rust中#[derive]的作用是什么?

老码GoRust

已于 2024-11-22 08:54:11 修改

阅读量425

点赞数 13

分类专栏： Rust 文章标签： rust 开发语言后端

于 2024-11-21 19:46:48 首次发布

本文链接：https://blog.csdn.net/weixin_43001122/article/details/143953024

版权

Rust 专栏收录该内容

17 篇文章

订阅专栏

在 Rust 中，#[derive] 是一个属性，用于自动为类型生成常见的实现，比如 Clone、Debug 等。它能极大地减少重复代码，同时确保实现的正确性和一致性。

基本语法

#[derive(Trait1, Trait2, ...)]
struct MyStruct {
    field1: Type1,
    field2: Type2,
}

功能: 自动生成指定特性的实现。
作用对象: 可以用于 struct、enum 和 union。

常见的 #[derive] 特性

Debug：自动生成类型的调试表示，用于格式化输出（通常用于打印或调试）。

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

fn main() {
    let s = MyStruct { x: 10, y: 3.14 };
    println!("{:?}", s); // 输出: MyStruct { x: 10, y: 3.14 }
}

Clone：生成类型的深拷贝方法。

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

fn main() {
    let s1 = MyStruct { x: 42, y: "Hello".to_string() };
    let s2 = s1.clone();
    println!("s1: {:?}, s2: {:?}", s1, s2);
}

Copy：表示类型支持按值拷贝（通常与 Clone 配合使用）。

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

fn main() {
    let p1 = Point { x: 0, y: 0 };
    let p2 = p1; // 不会移动，直接复制
    println!("{:?}, {:?}", p1, p2);
}

注意: 只能用于所有字段都实现了 Copy 的类型。

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 };
    println!("{}", p1 == p2); // 输出: true
}

PartialOrd 和 Ord：实现类型的排序特性，用于比较或排序。

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

fn main() {
    let p1 = Point { x: 1, y: 2 };
    let p2 = Point { x: 2, y: 3 };
    println!("{}", p1 < p2); // 输出: true
}

Default：为类型生成默认值。

#[derive(Default)]
struct Config {
    port: u16,
    host: String,
}

fn main() {
    let default_config: Config = Default::default();
    println!("Port: {}, Host: {}", default_config.port, default_config.host);
}

Hash：实现哈希特性，用于类型作为哈希表的键。

use std::collections::HashSet;

#[derive(Hash, Eq, PartialEq, Debug)]
struct User {
    id: u32,
    name: String,
}

fn main() {
    let mut users = HashSet::new();
    users.insert(User { id: 1, name: "Alice".to_string() });
    users.insert(User { id: 2, name: "Bob".to_string() });
    println!("{:?}", users);
}

组合使用

#[derive(Debug, Clone, PartialEq)]
struct MyStruct {
    x: i32,
    y: String,
}

fn main() {
    let s1 = MyStruct { x: 10, y: "Rust".to_string() };
    let s2 = s1.clone();
    println!("{:?}", s1 == s2); // 输出: true
    println!("{:?}", s2);       // 输出: MyStruct { x: 10, y: "Rust" }
}