Rust学习笔记007：Trait --- Rust的“接口”

已于 2024-07-06 18:22:41 修改
阅读量1.4k 收藏 11
点赞数 16
文章标签： rust 学习 笔记
于 2024-07-02 18:36:07 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/resumeproject/article/details/135328131
版权

Trait

  • 在Rust中，Trait（特质）是一种定义方法集合的机制，类似于其他编程语言中的接口（java）或抽象类(c++的虚函数)。

定义Trait

trait MyTrait { //关键字trait(线条、特征、勾勒)
    // 定义Trait的方法
    fn my_method(&self);//只有方法签名，没有具体实现，实现该trait的类型必须提供具体实现

    // 可选：可以在这里定义其他方法
    fn my_method_1(&self)-> String {
        String::from("也可以提供默认实现")
    };
}

实现Trait

struct MyStruct;

//实现trait用impl这个关键字，格式为impl trait_name for struct_name{}。impl另一个主要的用途是实现struct的“类成员方法”，格式为impl struct_name{}
impl MyTrait for MyStruct {
    fn my_method(&self) {
        println!("This is the implementation for my_method in MyStruct");
    }
}

孤儿规则

  • 可在某个类型上实现trait:

    • 类型或者trait在当前作用域中定义的

  • 无法为外部类型来实现外部的trait:

    • 这个限制是程序属性的一部分（也就是一致性）。
    • 更具体的说是孤儿规则：之所以这样命名是因为父类型不存在。
    • 此规则确保其他人的代码不能破坏您的diamond，反之亦然。
    • 如果没有这个规则，两个crate可以为同一个理性实现同一个trait,Rust就不知道该使用哪个实现了。
    • 如果允许任意 crate 对任意类型实现任意 trait，可能会导致多个 crate 中的相同类型实现相同的 trait，这会引起冲突和不可预期的行为。

引入与使用Trait

简单示例：

// 定义一个 Trait
trait Animal {
    fn make_sound(&self);
}

// 实现 Trait for struct Dog
struct Dog;

impl Animal for Dog {
    fn make_sound(&self) {
        println!("Woof!");
    }
}

// 使用 Trait 对象
fn print_sound(a: &dyn Animal) {
    a.make_sound();
}

fn main() {
    let dog = Dog;
    // 两种调用方法
    dog.make_sound(); // 输出: Woof!
    print_sound(&dog); // 输出: Woof!
}

将trait打包到库中

在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

Trait作为参数

在这里插入图片描述

使用多个Trait

// 定义两个trait，一个“总结”，一个“展示”
trait Summary {
    fn summarize(&self) -> String;
}
trait Display {
    fn display(&self);
}



// 定义结构体 CCTV
struct CCTV {
    author: String,   content: String,
}
// 为CCTV实现总结功能
impl Summary for CCTV {
    fn summarize(&self) -> String {
        format!("{}, by {}", self.content, self.author)
    }
}
// 为CCTV实现展示功能
impl Display for CCTV {
    fn display(&self) {
        println!("Author: {}", self.author);
        println!("Content: {}", self.content);
    }
}



// 定义一个函数，接受实现了 Summary 和 Display traits 的对象作为参数
pub fn notify(item: &(impl Summary + Display)) {
    println!("Breaking news!");
    println!("Summary: {}", item.summarize());
    item.display();
}



fn main() {
    let article = CCTV {
        author: "Sports editor".to_string(),
        content: "2024欧洲杯 聚焦绿茵盛宴！".to_string(),
    };

    notify(&article);
}
  • 运行结果：
Breaking news!
Summary: 2024欧洲杯 聚焦绿茵盛宴！, by Sports editor
Author: Sports editor
Content: 2024欧洲杯 聚焦绿茵盛宴！

// 定义两个trait，一个“总结”，一个“展示”
trait Summary {
    fn summarize(&self) -> String;
}
trait Display {
    fn display(&self);
}

// 定义结构体 CCTV
struct CCTV {
    author: String,   content: String,
}

// 为CCTV实现总结功能
impl Summary for CCTV {
    fn summarize(&self) -> String {
        format!("{}, by {}", self.content, self.author)
    }
}

// 为CCTV实现展示功能
impl Display for CCTV {
    fn display(&self) {
        println!("Author: {}", self.author);
        println!("Content: {}", self.content);
    }
}

// 定义Hacknews 结构体
struct Hacknews {
    username: String,
    content: String,
}
// 为Hacknews实现“展示功能”
impl Display for Hacknews {
    fn display(&self) {
        println!("Tweet by {}: {}", self.username, self.content);
    }
}

// 定义一个函数，接受实现了 Summary 和 Display traits 的对象作为参数
pub fn notify(item: &(impl Summary + Display)) {
    println!("Breaking news!");
    println!("Summary: {}", item.summarize());
    item.display();
}

fn main() {
    let article = CCTV {
        author: "Sports editor".to_string(),
        content: "2024欧洲杯 聚焦绿茵盛宴！".to_string(),
    };

    let hack = Hacknews {
        username: "Mako".to_string(),
        content: "fast, production-grade web bundler based on Rust (makojs.dev) ! from https://makojs.dev/blog/mako-open-sourced".to_string(),
    };

    notify(&article);
    // 需要多个trait都实现了才能运行
    // notify(&hack); // 报错 the trait bound 'Tweet:summary' is not satisfied ,the trait 'summary' is implemented for 'NewsArticle'
}

泛型中使用Trait

// 定义两个Trait
trait Printable {
    fn print(&self);
}

trait Drawable {
    fn draw(&self);
}

// 实现这两个Trait的类型
struct Circle {
    radius: f64,
}

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

impl Drawable for Circle {
    fn draw(&self) {
        println!("Drawing a circle with radius {}", self.radius);
    }
}

// 函数接受实现了两个Trait的类型
fn print_and_draw<T>(item: &T)
where
    T: Printable + Drawable,
{
    item.print();
    item.draw();
}

fn main() {
    let c = Circle { radius: 3.5 };

    c.print(); // 输出: Circle with radius 3.5
    c.draw();  // 输出: Drawing a circle with radius 3.5

    print_and_draw(&c);
}

trait bound形式

  • 从以上的例子中可以发现。在 Rust 中，有两种主要的方式来约束泛型类型参数必须实现特定的 trait（特性）：trait bound 形式和 impl Trait 语法糖形式。让我们来详细比较它们：

  • Trait Bound 形式：Trait bound 形式使用 where 子句来为泛型类型参数指定 trait 约束。例如：

fn example<T>(item: &T) -> usize
where
    T: Display + Clone,
{
    // 函数体
}

  • 这里 T: Display + Clone 表示泛型类型 T 必须同时实现 Display 和 Clone 这两个 trait。关键点在于 where 子句可以将多个 trait 约束放在一起，并且在使用泛型时可以非常清晰地看到这些约束。

  • impl Trait 语法糖形式

impl Trait 语法糖形式用于在函数签名中直接指定参数必须实现的一个或多个 trait。例如：

fn notify(item: &(impl Summary + Display)) {
    // 函数体
}
  • 这里 &(impl Summary + Display) 表示 item 参数必须实现 Summary 和 Display 这两个 trait。这种写法更加简洁和紧凑，适用于函数参数较少且只有少数几个约束的情况。

Ttait作为返回类型

在这里插入图片描述
在这里插入图片描述

#[derive(Trait)]

  • 在定义一些struct往往会有#[derive(Debug)]标签。Debug trait 是 Rust 标准库提供的一个 trait，用于以调试输出的格式打印类型的实例。当一个结构体或枚举被标记为 #[derive(Debug)] 时，Rust 编译器会自动为这个类型生成实现 Debug trait 的代码。这使得我们可以通过使用 {:?} 或者 println!("{:?}", value) 等方式打印这个类型的实例。

    #[derive(Debug)]
struct MyStruct {
    field1: i32,
    field2: String,
}
    • 在这个例子中，MyStruct 结构体通过 #[derive(Debug)] 派生了 Debug trait。这样，我们就可以使用 println!("{:?}", my_struct_instance) 来打印 MyStruct 的实例。

  • 更多相关 #[derive(Trait)]的内容可去了解一下过程宏，下面是一个例子，使得在主程序中可以使用宏 AnswerFn 来自动生成一个 answer() 函数，可以按照以下步骤进行：

第一步：创建 proc-macro crate
  1. 在一个新目录中创建一个 Cargo 项目：
cargo new proc-macro-examples --lib
  1. 将 Cargo.toml 文件中的内容更新为：
[package]
name = "proc-macro-examples"
version = "0.1.0"
edition = "2021"

[lib]
proc-macro = true

[dependencies]
# 没有依赖
  1. 更新 src/lib.rs 文件，添加 proc-macro 的实现：
#![crate_type = "proc-macro"]
extern crate proc_macro;
use proc_macro::TokenStream;

#[proc_macro_derive(AnswerFn)]
pub fn derive_answer_fn(_item: TokenStream) -> TokenStream {
    "fn answer() -> u32 { 123 }".parse().unwrap()
}
第二步：创建使用宏的应用程序

接下来，创建一个使用 proc-macro crate 的 Rust 应用程序。这个应用程序将使用宏 AnswerFn 来为一个结构体自动生成 answer() 函数。

  1. 创建另一个新的 Rust 项目：
cargo new macro-app
  1. 更新 Cargo.toml 文件以依赖于我们刚刚创建的 proc-macro crate：
[package]
name = "macro-app"
version = "0.1.0"
edition = "2021"

[dependencies]
proc-macro-examples = { path = "../proc-macro-examples" }
  1. 更新 src/main.rs 文件，使用宏 AnswerFn：
extern crate proc_macro_examples;
use proc_macro_examples::AnswerFn;

#[derive(AnswerFn)]
struct Struct;

fn main() {
    assert_eq!(123, answer());
}
编译和运行
  • 先编译proc-macro-examples
cd proc-macro-examples
cargo build

然后，可以编译并运行应用程序：

cd macro-app
cargo run
  • 运行结果
PS C:\Users\kingchuxing\Documents\learning-libp2p-main\macro-app> cargo run
warning: `macro-app` (bin "macro-app") generated 1 warning
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.34s
     Running `target\debug\macro-app.exe`
PS C:\Users\kingchuxing\Documents\learning-libp2p-main\macro-app>
FakeOccupational
关注
Rust通用代码生成器：莲花-Rust资源
07-01
RustJavaRust rust 1.69Axum 0.6.20Tokio 1.32.0sqlx 0.7.1MariaDB, MySQL 8, PostgreSQLOracle
Rust-trait
andy的博客
01-13 1117
Rust语言中的trait是非常重要的概念。在Rust中，trait这一个概念承担了多种职责。在中文里，trait可以翻译为“特征”“特点”“特性”等。
Rust特征(Trait)
zy010101博客
03-05 1724
如果不同的类型具有相同的行为，那么我们就可以定义一个特征，然后为这些类型实现该特征。定义特征是把一些方法组合在一起，目的是定义一个实现某些目标所必需的行为的集合。例如，我们现在有圆形和长方形两个结构体，它们都可以拥有周长，面积。因此我们可以定义被共享的行为，只要实现了特征就可以使用。// 为几何图形定义名为Figure的特征 fn girth(& self) -> u64;// 计算周长 fn area(& self) -> u64;// 计算面积 }
Rust基础
最新发布
qq_15203169的博客
09-11 1391
Rust开发基础知识学习与整理
弄懂Rust编程中的Trait
这里是二进制空间安全博客,主要分享网络安全、信息安全和数据安全相关的技术文章。内容覆盖编程语言、基础知识、漏洞分析、攻防技巧、安全工具使用、最佳实践等安全技术主题。
11-21 1119
trait 定义了某个特定类型拥有可能与其他类型共享的功能。可以通过 trait 以一种抽象的方式定义共享的行为。可以使用 trait bounds 指定泛型是任何拥有特定行为的类型。
Rust：Trait 详解
weixin_52617269的博客
07-12 2524
Rust语言里不同的type(比如 struct, enum等)可以调用的函数主要包括本身实现的方法。此外，Rust也提供了trait来定义不同type所需的“common behavior”，以此简化代码。一个trait里面可以包含多个method 对type实现trait: 以strcut为例，对struct实现trait，方式与实现struct方法类似。实现时可以选择 重写trait中的method，也可以选择不重写，直接使用trait中默认的method定义 结果： 实例化struct，
Rust 中 Trait 的使用及实现分析
Julia & Rust & Python
05-07 3215
Rust 中 Trait 的使用及实现分析 尘香 蚂蚁智能监控 今天 使用方式 基本用法 静态派发 动态派发 impl trait 高阶用法 关联类型 Derive 常见问题 向上转型（upcast） 向下转型（downcast） Object safety 总结 参考 在 Rust 设计目标中，零成本抽象是非常重要的一条，它让 Rust 具备高级语言表达能力的
Rust开发——Trait的概念与应用示例
知来者逆的博客
07-18 992
Rust Trait 的概念与详细使用示例
rust-crypto-nacl:Rust-Crypto-NaCl
06-25
Rust-Crypto-NaCl 选定 NaCl 原语的基于 Rust-Crypto 的实现。 Rust-Crypto-NaCl 试图从流行的 NaCl/TweetNaCl/libsodium 密码库家族中提供精选的高级原语。 具有仿照 API 的 C++ 版本建模的接口。用法要使用 Rust-...
rust-pcap:rust-lang的libpcap绑定
05-18
注意：此存储库和项目已废弃。 您可能应该使用： : 防锈帽建造git clone http://github.com/colemickens/rust-pcapcargo build 注意：您可能应该使用： :
godot-rust-first-try：godot-rust绑定：first-try
02-04
"godot-rust-first-try"项目就是将这两者结合，通过Godot的NativeScript特性实现Rust语言与Godot的绑定，为开发者提供更高效、更安全的游戏开发体验。 Godot的NativeScript是Godot引擎的一种脚本方式，它允许开发者...
rust-http2:Rusttokio中的HTTP2实现
05-03
基于tokio的Rust中的HTTP / 2客户端和服务器实现。 当前，它用作实现。 示例服务器 签出源代码并执行命令： cargo run --example server 服务器将在上可用。 您需要任何具有HTTP / 2支持的现代浏览器来打开页面...
Rust Trait简介
weixin_45730130的博客
11-28 1172
rust的简单介绍
Rust核心特性—Trait实例详解
Da_zhenzai的博客
03-27 905
Trait是Rust编程语言中的一种特性，它可以用于定义共享行为，类似于其他语言中的接口或抽象类。Trait的目的是允许程序员在不同类型之间共享代码，同时保持类型的安全性。LZ将对Trait进行全面的讲解，并提供一些实例来帮助读者更好地理解。在Rust中，Trait是一种非常强大的特性。Trait可以定义通用的方法和行为，可以用于描述多种类型的共性。Trait的默认实现可以减少代码重复，关联类型可以使Trait更加灵活，而where子句可以约束泛型类型的范围。
如何在rust中使用泛型，trait对象的总结以及kv sever（3）
weixin_53344209的博客
04-13 804
可以说在 Rust 开发中，泛型编程是我们必须掌握的一项技能。在你构建每一个数据结构或者函数时，最好都问问自己：**我是否有必要在此刻就把类型定死？**是不是可以把这个决策延迟到尽可能靠后的时刻，这样可以为未来留有余地？如果我们能通过泛型来推迟决策，系统的架构就可以足够灵活，可以更好地面对未来的变更。前面学习到trait可以实现参数多态，就是函数或者数据结构用T表示，不是具体类型； 还可以实现特设多态，也就是函数重载，一个函数接口不同的参数有不同的实现； 更牛逼的就是trait做参数的时候，可以实现特征约束
rust中的类型系统（trait的了解）
weixin_53344209的博客
04-01 829
有些静态语言，如C和C++，在编译期并不检查数组是否越界访问，运行时可能会得到难以意料的结果，而程序依旧正常运行，这属于类型系统中未定义的行为，所以它们不是类型安全的语言。，这样的类型系统就叫作多态类型系统。Rust中绝大部分类型都是在编译期可确定大小的类型（SizedType），比如原生整数类型u32固定是4个字节，u64固定是8个字节，等等，都是可以在编译期确定大小的类型。比如str类型的字符串字面量，编译器不可能事先知道程序中会出现什么样的字符串，所以对于编译器来说，str类型的大小是无法确定的。
Rust泛型与trait特性，模仿接口的实现
03-07 1030
泛型是一个编程语言不可或缺的机制。C++ 语言中用"模板"来实现泛型，而 C 语言中没有泛型的机制，这也导致 C 语言难以构建类型复杂的工程。泛型机制是编程语言用于表达类型抽象的机制，一般用于功能确定、数据类型待定的类，如链表、映射表等。这是一个对整型数字选择排序的方法： 运行结果： 这是一个简单的取最大值程序，可以用于处理 i32 数字类型的数据，但无法用于 f64 类型的数据。通过使用泛型我们可以使这个函数可以利用到各个类型中去。但实际上并不是所有的数据类型都可以比大小，所以接下来一段代码并不是
RUST 每日一省：泛型约束——trait
The future is already here it's just not evenly distributed。
05-01 1002
使用泛型编程时， 很多情况下的行为并不是针对所有类型都实现的，用trait作为泛型的约束。例如，我们编写一个判断两个变量大小的泛型函数，编译时，会运行如下错误。这个编译错误是说， 由于泛型参数T没有任何约束——如果我们填入两个Struct类型，如何比较呢， 因此编译器认为a<b这个表达式是不合理的， 因为它只能作用于支持比较运算符的类型。编译器也进行了提示，只有impl了PartialOrd的类型， 才能支持比较运算符。修正如下。
第N次入门Rust - 9.泛型、trait和生命周期
你好！
07-31 1243
这一篇介绍Rust的核心泛型、trait和生命周期~
rust trait中怎么定义常量
04-01
在rust trait中定义常量可以使用关键字`const`，并在其前面加上`pub`关键字表示公共可见性，例如： ``` trait MyTrait { pub const MY_CONST: i32 = 100; } ``` 在这个例子中，我们定义了一个公共的常量`MY_CONST`，其值为`100`，可以在实现该trait的任何代码中使用。注意，常量必须是编译时常量，不能是动态计算得到的值。
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值