generics-traits/trait-object

[giscus[bot]]

generics-traits/trait-object

Learn Rust with Example, Exercise and real Practice, written with ❤️ by https://course.rs team

https://practice.rs/generics-traits/trait-object.html

[lijing-2008]

fn hatch_a_bird(num: u8) -> Box<dyn Bird>{
    match num {
        1 => Box::new(Swan),
        _ => Box::new(Duck),
    }
}

[lijing-2008]

    let birds:[Box<dyn Bird>; 2] = [Box::new(Duck), Box::new(Swan)];

[s724123]

出现了报错

the trait Iterator is not implemented for [Box<dyn Bird>; 2]

后来写成了

let birds: &[Box<dyn Bird>;2] = &[Box::new(Duck {}), Box::new(Swan {})];

但是不明所以

[doooooit]

可以使用 Vec：

let birds: Vec<Box<dyn Bird>> = vec![Box::new(Duck), Box::new(Swan)];

[lijing-2008]

// 通过泛型实现以下函数
fn static_dispatch<T>(param: T)
    where T:Foo
{
    println!("{}", param.method());
}

// 通过特征对象实现以下函数
fn dynamic_dispatch(param:&dyn Foo){
    println!("{}", param.method());
}

[klenkiven]

第四题也可以通过 impl 语法实现，不过不知道是不是合乎规矩的

fn static_dispatch(foo: impl Foo) {
    foo.method();
}

[jesHrz]

这俩应该是等价的吧？

fn static_dispatch<T: Foo>(foo: T) {
    foo.method();
}

[labuladong]

是一样的，之前讲了 impl 就是泛型的语法糖

[makexiao113]

done，本节主要讲了特征对象的相关知识，其中使用到了dyn关键字，这个dyn关键字我觉得和rust最初的设计理念并不相符，因为rust本身是想要在编译阶段就确定所有参数的类型的，这样程序的运行时性能才会最高，dyn动态分发就破坏了这一理念，拙见，轻喷

[sunface]

毕竟还要考虑工程性 🤣

[DrEden33773]

done！这里的第六题有一个新的思路，使用 泛型特征(Generic Traits) ，代码如下:

trait MyTrait<T> {
    fn f(&self) -> T;
}

impl MyTrait<u32> for u32 {
    fn f(&self) -> u32 { 42 }
}

impl MyTrait<String> for String {
    fn f(&self) -> String { self.clone() }
}

fn my_function<T: MyTrait<T>> (x: Box<dyn MyTrait<T>>) -> T { // could be discarded
    x.f()
}

fn my_function_2<T: MyTrait<T>> (x: Box<T>) -> T { // could be discarded
    x.f()
}

fn main() {
    my_function(
        Box::new(13_u32)
    );
    my_function(
        Box::new( String::from("abc") )
    );
    my_function_2(
        Box::new(13_u32)
    );
    my_function_2(
        Box::new( String::from("abc") )
    );

    println!("Success!")
}

[wangshankun]

特征对象的特征对象，要求方法没有任何泛型参数；
fn f(&self) -> T; 合理？

[lsmind]

这里的泛型参数是trait的，而不是方法的。但由于用到了trait绑定，两个my_function其实都是静态分发的。

[DrEden33773]

再更新一个6的思路

trait MyTrait {
    type Output;
    fn f(&self) -> Self::Output;
}

impl MyTrait for u32 {
    type Output = u32;
    fn f(&self) -> Self::Output { 42 }
}

impl MyTrait for String {
    type Output = String;
    fn f(&self) -> Self::Output { self.clone() }
}

fn my_function<T: MyTrait<Output = T>> (
    x: Box<dyn MyTrait<Output = T>>
) -> T { // could be discarded
    x.f()
}

fn my_function_2<T: MyTrait<Output = T>> (
    x: Box<T>
) -> T { // could be discarded
    x.f()
}

fn main() {
    my_function(
        Box::new(13_u32)
    );
    my_function(
        Box::new( String::from("abc") )
    );
    my_function_2(
        Box::new(13_u32)
    );
    my_function_2(
        Box::new( String::from("abc") )
    );

    println!("Success!")
}

[Tlntin]

哈哈，刚好我想到的两个思路就是这两个。题解的那两个思路反而没想那边去。

[DrEden33773]

哈哈

[wangshankun]

来个花活，虽然编译过去了，但是应该属于静态的

// 通过特征对象实现以下函数,
fn dynamic_dispatch(a:&impl Foo) {
a.method();
}

[haochen-zeng]

Done.

[AliceThunder]

done

[worldstearly]

trait MyTrait {
    fn f(&self);
}

impl MyTrait for u32 {
    fn f(&self) {}
}

impl MyTrait for String {
    fn f(&self) {}
}

fn my_function(x: Box<dyn MyTrait>) {
    x.f()
}

fn main() {
    my_function(Box::new(13_u32));
    my_function(Box::new(String::from("abc")));

    println!("Success!")
}

[Bruce012356]

mark

[crypto-le]

第二题可以根据特征对象的学习内容 写成

let birds : Vec<Box> = vec![Box::new(Duck{}),Box::new(Swan{})];;

[crypto-le]

let birds : Vec<Box<dyn Bird>> = vec![Box::new(Duck{}),Box::new(Swan{})];;

[pluschen-stack]

trait MyTrait {
    fn f(&self) -> Self;
}

impl MyTrait for u32 {
    fn f(&self) -> u32 { 42 }
}

impl MyTrait for String {
    fn f(&self) -> String { self.clone() }
}

fn my_function(x: impl MyTrait) -> impl MyTrait  {
    x.f()
}

fn main() {
    my_function(13_u32);
    my_function(String::from("abc"));
}

第五题的这个为什么可以通过啊，my_function()不是返回了两种不同的类型（u32和String）吗

[kraymond37]

查看可执行程序的符号

nm target/debug/rusttest | grep my_function
0000000000008840 t _ZN8rusttest11my_function17h33bb2c02b4f2410cE
00000000000088a0 t _ZN8rusttest11my_function17he6c8f4e1b0e55b2eE

[kraymond37]

不同意kahosan的说法, Self确实是一个特殊的关键字, 但它只是表示当前类型. 参考下面这段代码, 都返回Self, 但是无法编译通过.

trait Hello {
    fn new() -> Self;
}    

struct A;
struct B;

impl A {
    fn new() -> Self {
        A
    }
}

impl B {
    fn new() -> Self {
        B
    }
}

fn returns_hello(switch: bool) -> impl Hello {
    if switch {
        A::new()
    } else {
        B::new()
    }
}

[u3l6]

如果使用的是特征对象（例如Box），那么必须替换Self为具体类型。但是这种解决方案中没有使用特征对象，使用的是泛型（impl MyTrait是泛型的语法糖），所以留着Self也可以
而且这样写和第一种标准答案是没什么区别的，只要不使用特征对象写不写Self无所谓，下面有没有Box<>也都一样

个人观点，大佬轻喷

[ARCJ137442]

不同意kahosan的说法, Self确实是一个特殊的关键字, 但它只是表示当前类型. 参考下面这段代码, 都返回Self, 但是无法编译通过.

trait Hello {
    fn new() -> Self;
}    

struct A;
struct B;

impl A {
    fn new() -> Self {
        A
    }
}

impl B {
    fn new() -> Self {
        B
    }
}

fn returns_hello(switch: bool) -> impl Hello {
    if switch {
        A::new()
    } else {
        B::new()
    }
}

这里也没有impl Hello for A和impl Hello for B啊
本身没有实现A: Hello、B: Hello就会报错

[vhtmui]

不同意kahosan的说法, Self确实是一个特殊的关键字, 但它只是表示当前类型. 参考下面这段代码, 都返回Self, 但是无法编译通过.

trait Hello {
    fn new() -> Self;
}    

struct A;
struct B;

impl A {
    fn new() -> Self {
        A
    }
}

impl B {
    fn new() -> Self {
        B
    }
}

fn returns_hello(switch: bool) -> impl Hello {
    if switch {
        A::new()
    } else {
        B::new()
    }
}

要从rust编译器的设计理念思考，你这个例子函数returns_hello()在运行时返回多种类型，而层主的my_function()方法在运行时返回单一类型（单态化编译之后）。

[Nixicodo]

10.4特征对象第5题，我有一种邪道做法hhh，把函数都设置为不返回值

// 使用至少两种方法让代码工作
// 不要添加/删除任何代码行
trait MyTrait {
    fn f(&self);
}

impl MyTrait for u32 {
    fn f(&self){ 42 ;}
}

impl MyTrait for String {
    fn f(&self)  { self.clone() ;}
}

fn my_function(x: Box<dyn MyTrait>)  {
    x.f();
}

fn main() {
    my_function(Box::new(13_u32));
    my_function(Box::new(String::from("abc")));

    println!("Success!")
}

[ARCJ137442]

调用者：我**，我***🤣

[ospdz]

跟我写的一模一样，哈哈

[XU0618]

lala~

[chenhai998]

done

[yawyuen]

第二题 三种方式:

let birds:Vec<&dyn Bird> = vec![&Duck, &Swan]

let birds:Vec<Box<dyn Bird>>=vec![Box::new(Duck),Box::new(Swan)]

let birds:[Box<dyn Bird>;2] = [Box::new(Duck), Box::new(Swan)]

[doooooit]

第5题

1. 使特征具备可以转换为特征对象的条件

trait MyTrait<T> {
    fn f(&self) -> T;
}

impl MyTrait<u32> for u32 {
    fn f(&self) -> u32 { 42 }
}

impl MyTrait<String> for String {
    fn f(&self) -> String { self.clone() }
}

fn my_function<T>(x: Box<dyn MyTrait<T>>) -> T {
    x.f()
}

fn main() {
    my_function(Box::new(13_u32));
    my_function(Box::new(String::from("abc")));

    println!("Success!")
}

2. 不用特征对象

trait MyTrait {
    fn f(&self) -> Self;
}

impl MyTrait for u32 {
    fn f(&self) -> Self { 42 }
}

impl MyTrait for String {
    fn f(&self) -> Self { self.clone() }
}

fn my_function(x: impl MyTrait) -> impl MyTrait {
    x.f()
}

fn main() {
    my_function(13_u32);
    my_function(String::from("abc"));

    println!("Success!")
}

[dequeueing]

第五题的官方题解：

    fn f(&self) -> Self;
}

impl MyTrait for u32 {
    fn f(&self) -> u32 { 42 }
}

impl MyTrait for String {
    fn f(&self) -> String { self.clone() }
}

fn my_function(x: impl MyTrait) -> impl MyTrait  {
    x.f()
}

fn main() {
    my_function(13_u32);
    my_function(String::from("abc"));
}```
请教一下，`fn my_function(x: impl MyTrait) -> impl MyTrait` 不是只能返回同一种类型的吗？为什么这里既返回了数值又返回了String也可以运行呢？

[BiteFoo]

这个应该是错误的，不能返回impl Trait ，看下 gpt 的分析结果：

在 Rust 中，使用 impl Trait 语法作为函数的返回类型表示一个不透明类型，它使得函数可以返回实现了特定 trait 的类型，而不需要显式地指定具体的类型。但是，在您的情况下，将 my_function 函数的签名改为 fn my_function(x: Box) -> impl MyTrait 会导致编译错误，原因是返回的类型不是确定的。

具体来说，在 Rust 中，impl Trait 语法用于返回一个特定类型，而在您的情况下，函数 my_function 可能会返回不同的类型（取决于传入的 Box 中具体的类型）。这样的设计在 Rust 中是不允许的，因为函数的返回类型必须是确定的。

因此，您不能将 my_function 函数的签名改为 fn my_function(x: Box) -> impl MyTrait，因为这样的返回类型是不确定的，无法满足 Rust 的类型系统要求。您需要使用 Box 作为返回类型，或者通过泛型参数来实现函数的多态性。

[ChinaRedArmy1930]

没太懂 为什么第二题这样写就不行

    let birds: [Box<dyn Bird>; 2] = [Box::new(Duck), Box::new(Swan)]; //可以
   let birds: Vec<Box<dyn Bird>> = [Box::new(Duck), Box::new(Swan)]; //不行

[ChinaRedArmy1930]

还是对rust语法不太熟悉，要这样写才行

  let birds: Vec<Box<dyn Bird>> = vec![Box::new(Duck), Box::new(Swan)];

[BokutoMan]

down

[felipe300]

• done

[MTDickens]

Done。最后一题，如果只考虑我们目前已经学过的方法，那么就是

1. 将 dyn 变成泛型，反正输入输出的类型都一样，用泛型就 OK 了。
   • 注意，这里同时要把 my_function 也改成泛型的方式实现
2. 将 Self 变成 Box 就行了，不违反“返回类型不能是 Self”这条规定

题解

将 dyn 变成泛型。

虽然违反了第二条规定，但是我们只要避免使用 dyn 即可——将所有函数都改成泛型实现。

trait MyTrait {
    fn f(&self) -> Self;
}

impl MyTrait for u32 {
    fn f(&self) -> Self { 42 }
}

impl MyTrait for String {
    fn f(&self) -> Self { self.clone() }
}

fn my_function (x: impl MyTrait ) -> impl MyTrait {
    x.f()
}

fn main() {
    my_function(13_u32);
    my_function(String::from("abc"));

    println!("Success!")
}

返回 Box 而不是 Self

从而避免违反第一条规定。

trait MyTrait {
    fn f(&self) -> Box<dyn MyTrait>;
}

impl MyTrait for u32 {
    fn f(&self) -> Box<dyn MyTrait> { Box::new(42) }
}

impl MyTrait for String {
    fn f(&self) -> Box<dyn MyTrait> { Box::new(self.clone()) }
}

fn my_function (x: &dyn MyTrait ) -> Box<dyn MyTrait> {
    x.f()
}

fn main() {
    my_function(&13_u32);
    my_function(&String::from("abc"));

    println!("Success!")
}

[MTDickens]

为什么 SomeTrait 中的方法不能返回 Self 呢？因为 &dyn SomeTrait 可以认为是这样的对象：

1. 不知道自己之前的类型是什么
2. 只有对应 SomeTrait 中方法的函数指针（指向自己之前类的实现）。

因此，如果让它返回 Self，那么就相当于让它返回自己之前的类型。然而它已经不记得自己之前的类型了，所以这样做是不可行的。

[Icemans007]

帮忙解答下这里是什么错误? &self.clone() 的类型和 self 的类型都是 &String，为什么clone的string取引用会报错？

// 使用至少两种方法让代码工作
// 不要添加/删除任何代码行
trait MyTrait {
    fn f(&self) -> &dyn MyTrait;
}

impl MyTrait for u32 {
    fn f(&self) -> &dyn MyTrait { &42 }
}

impl MyTrait for String {
    fn f(&self) -> &dyn MyTrait {
        // &self.clone() // 这里会失败 returns a value referencing data owned by the current function
        self  // 这里却可以
    }
}

fn my_function(x: &dyn MyTrait) -> &dyn MyTrait {
    x.f()
}

fn main() {
    my_function(&13_u32);
    my_function(&String::from("abc"));

    println!("Success!")
}

[vhtmui]

你返回了一个本地的值的引用，引用出去就变成悬垂指针了。能返回self因为self实际上是&Self类型，即位于外部作用域的此函数的调用者的引用。

[DylanJinx]

done~~~

[unpain]

done

[5angXR]

fn hatch_a_bird<'a>(select: i32) -> &'a dyn Bird {
match select {
1 => &Duck,
_ => &Swan,
}
}

[TDAkory]

mark finished

[ospdz]

// 使用至少两种方法让代码工作
// 不要添加/删除任何代码行
trait MyTrait {
fn f(&self) -> Self;
}

impl MyTrait for u32 {
fn f(&self) -> Self { 42 }
}

impl MyTrait for String {
fn f(&self) -> Self { self.clone() }
}

fn my_function(x: Box) {
x.f();
}

fn main() {
my_function(Box::new(13_u32));
my_function(Box::new(String::from("abc")));

println!("Success!")

}
不明白这样为什么不行，对于 my_function(Box::new(13_u32));这一行调用，参数就是x:Box，另一行调用参数是x:Box，看起来都是符合x: Box签名的。不知道为什么会不行，谁能解答一下吗？

[ospdz]

没有注意格式，我把问题再复述一下：对于 my_function(Box::new(13_u32));这一行调用，参数就是x:Box<u32>，另一行调用参数是x:Box<String>，看起来都是符合x: Box<dyn MyTrait>签名的。不知道为什么会不行

[bansal-harsh-2504]

Day 9
Done ✅