rust中trait使用方法

trait用中文来讲就是特征,它就是一个标记,只不过这个标记被用在特定的地方,也就是类型参数的后面,用来限定这个类型参数可能的类型范围。trait是一种约束。

具体关系为: 变量(值空间太过宽泛,添加约束) -> 类型(约束过死,放开约束) -> 泛型(类型空间太过宽泛,添加约束) -> trait

语法上,T: TraitA意思就是对类型参数T施加TraitA这个标记,具体实现为:

rust 复制代码
trait TraitA {}

struct Atype;

impl TraitA for Atype {}

对于某个类型T来说,如果它实现了这个TraitA,这个类型就满足约束

rust 复制代码
fn print<T: std::fmt::Display>(p: Point<T>){...}

上面这这段代码的意思是,Display对类型参数T做了约束,要求将来要带入的具体类型必须实现Display这个trait。也就是说,trait对类型参数施加约束的同时,也对具体的类型提供了能力,在Rust中约束和能力就是一体两面,是同一个东西。

trait中包含什么

trait里面可以包含关联函数、关联类型和关联常量。

关联函数

rust 复制代码
// 下列代码涉及所有权三态
trait Sport {
    fn play(&self) {} // 注意这里一对花括号,就是trait的关联函数的默认实现
    fn play_mut(&mut self);
    fn play_own(self);
    fn play_some() -> Self;
}

struct Football;
impl Sport for Football {
    // 由于play函数在trait中有关联函数的默认实现,结构体则可以不实现此函数
    fn play_mut(&mut self) {}
    fn play_own(self) {}
    fn play_some() -> Self { Self }
}

fn main() {
    let mut f = Football;
    f.play();
    f.play_mut();
    f.play_own();
    let _g = Football::play_some();
    let _g = <Football as Sport>::play_some(); // 等同于上一条代码
}

关联类型

在trait中,可以带一个或多个关联类型。关联类型起一个类型占位功能,定义trait时声明,在把trait实现到结构体上的时候为其指定具体的类型。

rust 复制代码
pub trait Sport {
    type ST; // 声明关联类型
    fn play(&self, st: Self::ST); // 将关联类型应用到关联函数
}

struct Football;
pub enum SportType {
    Land,
    Water,
}

impl Sport for Football {
    type ST = SportType; // 为关联类型指定具体类型
    fn play(&self, st: Self::ST){} // 方法中用到关联类型
}

fn main() {
    let f = Football;
    f.play(SportType::Land);
}

在T上使用关联类型

rust 复制代码
trait TraitA {
    type Mytype;
}

fn doit<T: TraitA>(a: T::Mytype) {} // 这里在函数中使用关联类型

struct TypeA;
impl TraitA for TypeA {
    type Mytype = String; // 具化关联类型为String
}

fn main() {
    doit::<TypeA>("abc".to_string()); // 指定泛型T为结构体TypeA
}

在约束中具化关联类型

rust 复制代码
trait TraitA {
    type Item;
}
// 意思就是限制x必须是实现TraitA而且它的关联类型Item必须是String的类型
struct Foo<T: TraitA<Item=String>> {
    x: T
}

对关联类型的约束

在定义关联类型的时候,也可以给关联类型添加约束。后面在具化这个类型的时候,那些类型必须要满足于这些约束

rust 复制代码
use std::fmt::Debug;

trait TraitA {
    type Item: Debug; // 这里对关联类型添加了Debug的约束
}

#[derive(Debug)]
struct A; // 这里在结构体A上自动derive Debug约束

struct B;

impl TraitA for B {
    type Item = A; // 这里类型A已经满足Debug约束
}

在使用时可以加强关联类型的约束

rust 复制代码
...
fn doit<T>(a: T)
where
    T: TriatA, // 约束T类型必须实现TraitA
    T::Item: Debug + PartialEq, // 同时约束trait的关联类型必须实现Debug和PartialEq
{
}

关联常量

和关联类型不同的是,关联常量可以在trait定义的时候指定,也可以在给具体类型实现的时候指定。

rust 复制代码
trait TraitA {
    const LEN: u32 = 10;
}

struct A;
impl TraitA from A {
    const LEN: u32 = 12;
}

where

当类型参数后面有对个trait约束的时候,会显得头重脚轻,所以Rust提供了where语法

rust 复制代码
fn doit<T: A + B + C + D + E + F>(t: T) -> i32 {}

fn doit<T>(t: T) -> u32
where
    T: A + B + C + D + E + F
{}

约束依赖

如果某种类型要实现TraitA,那么它也要同时实现TraitB。

rust 复制代码
trait TraitB {}
trait TraitA: TraitB {}
// 等价于
trait TraitC where Self: TraitB {}

约束之间是完全平等的,没有上下级关系

约束中同名方法的访问

rust 复制代码
trait Shape {
    fn play(&self) {
        println!("1");
    }
}
trait Circle: Shape {
    fn play(&self) {
        println!("2");
    }
}
struct A;
impl Shape for A {}
impl Circle for A {}
impl A {
    fn play(&self) {
        println!("3");
    }
}

fn main() {
    let a = A;
    a.play(); // 调用类型A上实现的play方法
    <A as Circle>::play(&a); // 调用trait Circle上的play方法
    <A as Shape>::play(&a); // 调用trait Shape上的play方法
}

这种语法叫做完全限定语法,是调用类型上某个方法的完整路径表达。

用trait实现能力配置

trait提供了寻找方法的范围

  1. 检查有没有直接在这个类型上实现这个方法
  2. 检查有没有在这个类型上实现某个trait,trait中有这个方法 一个类型可能实现了多个trait,不同的trait中各有一套方法,这些不同的方法中可能还会出现同名方法。Rust在这里采用了一种惰性的机制,由开发者指定在当前的mod或scope中使用哪套或哪几套能力。因此,对应地需要开发者手动地将要用到的trait引入当前scope。
rust 复制代码
mod module_a {
    pub trait Shape {
        fn play(&self) {
            println!("1");
        }
    }
    pub struct A;
    impl Shape for A {}
}
mod module_b {
    use supper::module_a::Shape; // 需要同时引入A用到的trait
    use super::module_a::A;
    
    fn doit() {
        let a = A;
        a.play();
    }
}

孤儿原则

为了不导致混乱,Rust要求在一个模块中,如果要对一个类型实现某个trait,这个类型和这个trait其中必须有一个是在当前模块定义的,如果必须用的话,可以用Newtyoe模式

Blanket Implementation

统一实现后,就不要对某个具体的类型再实现一次了,因为同一个trait只能实现一次到某个类型上。这个不像对类型做impl,可以实现多次(函数名要不冲突)。

rust 复制代码
trait TraitA {}
trait TraitB {}

impl<T: TraitB> TraitA for T {} // 为所有被TraitB约束的类型实现TraitA

impl TraitB for u32 {}
// impl TraitA for u32 {} // 无法再次实现
相关推荐
北城笑笑1 小时前
Vue 110 ,若依SSE流式接口限次空500排查与解决
前端·javascript·vue.js·后端·vue
ServBay2 小时前
Local harness 将退役,VS Code 本地开发要不要搬到云端?
后端·ai编程·visual studio code
ashiho2 小时前
【LeetCode hot 100】3. 无重复字符的最长子串 (三种解法)
java·数据结构·后端·算法·leetcode·滑动窗口
张一凡933 小时前
你的 AGENTS.md,真的管到模型写代码了吗?
前端·后端·agent
00后程序员3 小时前
iOS 实时活动怎么开发,Windows 上用 KXBuild 和 ActivityKit 写灵动岛
后端·ios
程序员cxuan3 小时前
推荐 10 个 WorkBuddy 中的邪修用法
人工智能·后端·程序员
Bacon4 小时前
给项目做一次"全身 CT":Agent Skills 生态里的代码体检全链路
前端·人工智能·后端
Java旅途4 小时前
课程表编排与调课申请系统|排得开,也能把每次调整管清楚
后端
象牙塔五六七4 小时前
Java 泛型精讲:从 Stream 源码说起
后端
掘金挖土4 小时前
前端手摸手跑路之 AI 应用开发(十二)
前端·后端