basic/trait/trait-object

[giscus[bot]]

basic/trait/trait-object

https://course.rs/basic/trait/trait-object.html

[giveahug]

看到这一脸懵逼

[chenxiaochun]

看了两遍，基本不懵逼了😂

[blkcor]

看了两遍刷了两遍题 基本不懵逼了

[lgdu]

正在懵逼的路上。。。

[yuliang0225]

目前为止最抽象的吧

[chenxiang0010]

反复入门几次就不懵逼了...

[overlords]

特征对象要划重点，得多温习

[chanhsiaoyu]

重点太多啦 :)

[hinego]

尚未完全理解

[ylinfy]

各位大佬们，怎么理解 Box动态分发，就像例子中：
let x = 1.1f64;
// do_something(&x);
let y = 8u8;

draw1(Box::new(x));
draw1(Box::new(y));

这里x, y不是已知类型么，为什么不能像静态分发一样，为u8和f64分别生成一份代码

[maolonglong]

fn draw3(x: &impl Draw) {
    x.draw();
}

fn main() {
    draw3(&1.1f64);
    draw3(&8u8);
}

这里是可以静态分发的，我的理解是，在一个流程里类型推导有歧义的话，才一定要用动态分发，就像 returns_summarizable 那样

[anson0370]

在你说的这个例子里 自然是可以用泛型来做静态分发的
请回头考虑文章中开始提出动态分发时的举例是用作返回值的场景

[kapaseker]

如果你的Box里面装的是一个trait object呢？这就是动态分发了。

[q269384828]

你的例子用静态分发没问题.
这里主要要看 Screen::components 的类型是怎么定义的.

一开始的需求就是:

1. 对象集合类型/个数 并不能事先明确地知道
2. 这个组件可能是三方实现的. (自定义组件)
3. 需要循环 draw

然后, 即便如此, 这种场景就不能做到静态分发吗? 是的,因为在编译器是不可能知道 componets 是怎么收集起来的. 那类型就不可能猜的出来了

[Nakiamii]

泛型+特征约束是静态分发的，特征对象是动态分发的。两个应用的场景不同。

[FlippedOvO]

fn add<T: Add<T, Output = T>>(a: T, b: T) -> T

这个 Output = T 没看懂啊

[bluecode2017]

我理解这里是要求返回值必须是输入的一样的数据类型
但也可以->U 比如两个数加一下变成一个字符串，是不是也可以？

[duanyuluo]

// define struct
#[derive(Debug, Copy, Clone, PartialEq)]
struct Point {
x: T,
y: T,
}

// Notice that the implementation uses the associated type Output.
impl<T: Add<Output = T>> Add for Point {
type Output = Self; // 这里有个关联类型，需要明确

fn add(self, other: Self) -> Self::Output {
    Self {
        x: self.x + other.x,
        y: self.y + other.y,
    }
}

}

[henda233]

可以把代码转换成使用Where约束：
fn add(a : T, b : T ) -> T
Where T: Add<T,Output=T>
这样比较好理解

[FlippedOvO]

放弃了1年之后再回来看了一遍 看懂了

[Raine-Yang-UofT]

我的理解是<T: Add<T, Output=T>>的意思是泛型T实现Add特征，并且T和T进行add操作返回值也是T。<T, Output=T>相当于对T: Add进行进一步说明Add的参数和返回值是什么。

[guodafeng]

最后好像没有直接给出一开始提出问题的解决方法， 是在练习里吗？
fn returns_summarizable(switch: bool) -> impl Summary {
if switch {
Post {
// ...
}
} else {
Weibo {
// ...
}
}
}

[OC0311]

这样子就好了
fn returns_summarizable(switch: bool) -> Box{
if b {
Box::new(Post{...})
}else{
Box::new(Weibo{...})
}

}

[OC0311]

这样子就好了
fn returns_summarizable(switch: bool) -> Box{
if b {
Box::new(Post{...})
}else{
Box::new(Weibo{...})
}

}

[OC0311]

fn returns_summarizable(switch: bool) ->Box<dyn Summary >{
if b {
Box::new(Post{...})
}else{
Box::new(Weibo{...})
}

}

[kapaseker]

Add trait 里面定义了一个关联类型的泛型，比较特殊，

pub trait Add<Rhs = Self> {
    type Output;
}

所以在声明的时候，也需要声明关联类型的类型。

[mxismean]

觉得 Box 智能指针能在本节做一个介绍，可能会更方便大家理解本节内容

[sunface]

好的，建议收到

[SifungLei]

特征对象，有点像java的接口类型，例如Map,List。例如:

List<String> list = new ArrayList<String>();

List是一个接口，ArrayList类型实现了List接口。

[stanhangzhou]

还是有很大区别的，特征trait 就是一种共享行为的抽象。 可以为任何类型，实现！ 比java接口灵活多了！，但是，由于孤儿规则。 特化还没实现，也有很多限制！ 哎，感觉抽象（继承）就不是很好实现。要不就要写特征宏，把抽象的的一种繁琐，转化为另外一种繁琐！

[bcyes168]

眼睛看懂了，手还没懂。练习题都不够撸。

[kaixinbaba]

"m1 max太厉害了，电脑再也不会卡"

我好像知道了什么，留下了贫穷的泪水

[tabris233]

m1 pro 也不卡，可以冲

[stanhangzhou]

哈哈 什么 mi max! 还是我的3090Ti 无敌！!

[shikelong]

看到这里，表示这是我学习 Rust 的第一个卡点。。

[stanhangzhou]

卡点？ m1 max吗？ 哈哈，多练练就有感觉了

[ZLD1819858]

同....真第一个卡点。

[yueqianzhang]

特征对象可以模拟继承

[yueqianzhang]

类似虚函数？
声明的类型是父类，实际绑定的是子类
用(表面)父类调用非 final 方法时，会动态派发到子类相同方法执行

[yueqianzhang]

+多态

[wxcree]

+1，感觉和C++的多态在效果上面很相像

[yuhao00]

子类可以继承父类的成员变量，trait不能定义成员变量。

[Lartimes]

不是严格的继承， 顶多算是广度实现，他只是一个维度， 比说说我这个trait 会返回一堆实现struct 、 enum 什么的，我可以用dyn 动态获取其引用，封装起来， 但是获取的实例只能操作方法，不与原生struct、enum有关

[NinjaSlayerSang]

其实就是“多态”，在不同的语言里面有不同的名称、语法和实现方式，比如c语言就是用不安全的指针粗暴地实现，c++用虚函数来实现，java通过抽象类与接口来实现，像go，swift这种很新的语言都倾向于通过更灵活的鸭式辨型的抽象来实现多态和动态派发，go里面叫interface，swift里面叫protocol，而rust里面就叫trait

[Leo-Lionni]

为自定义类型实现 + 操作

给struct Point加 :Add<T,Output =T > 和 不加 有什么区别呢?
我的理解是
加不加都无法限制 不符合Add<T,Output =T >的 Point 实例 被创建呀!

请大佬讲解下

[Yurzi]

加了这个能确保你在实现Point的Add特征时，其内部的T是实现了Add特征的。

[tabris233]

修复上一节中的 largest 函数

用下标处理，就不需要 Copy 了。

fn largest<T: PartialOrd>(list: &[T]) -> &T {
    let mut largest_idx = 0_usize;
    
    for i in 0..list.len() {
        if list[i] > list[largest_idx] {
            largest_idx = i;
        }
    }

    &list[largest_idx]
}

[ztsweet]

非常感谢

[OliCoder]

more graceful way to implement this method

pub fn largest<T>(list: &[T]) -> &T
    where T: Ord {
    list.iter()
        .map(|x| x)
        .max()
        .expect("find largest item failed")
}

[duanyuluo]

你这个太实战了，不适合用来讲解 ：D

[smallevilbeast]

map 多余了

pub fn largest<T>(list: &[T]) -> &T
    where T: Ord {
    list.iter().max().unwrap()
}

[lgdu]

没看明白这里为什么把&item修改为item，能解释一下么？

[cybertheye]

这个特征对象限制，对象安全的官方资料有吗

[Wan-Yifei]

有的，https://doc.rust-lang.org/reference/items/traits.html
官方列出的限制条件比文中更多。

[Wan-Yifei]

老想起Python的装饰器

[jockchou]

struct Point<T: Add<T, Output = T>>）这里第二个T，Add<T，Output= T>，代表的是+号的右操作数的类型吗？p.x的类型？
x: self.x + p.x,

[restart126]

感觉既然泛型参数都在编译期都能编译了，这个特征对象在编译期间也能实现啊，就把所以实现了这个特征的类型都编译一下，这样也就静态分发了，不太明白特征对象这种动态分发的设计优势是在哪里

[Wan-Yifei]

但是对于泛型类型参数来说，当使用特征时其会放入具体的类型参数：此具体类型变成了实现该特征的类型的一部分。而当使用特征对象时其具体类型被抹去了，故而无从得知放入泛型参数类型到底是什么。

这句话我不太理解，能提供一个例子吗？

[Wan-Yifei]

回答我自己的问题吧：
例子：

// This trait is object-safe, but these methods cannot be dispatched on a trait object.
trait NonDispatchable {
    // Non-methods cannot be dispatched.
    fn foo() where Self: Sized {}
    // Self type isn't known until runtime.
    fn returns(&self) -> Self where Self: Sized;
    // `other` may be a different concrete type of the receiver.
    fn param(&self, other: Self) where Self: Sized {}
    // Generics are not compatible with vtables.
    fn typed<T>(&self, x: T) where Self: Sized {}
}

官方例子。另外简单的解释就是泛型T是静态分发的，而trait用作特征对象时需要动态分发，两者不兼容。另外动态分发的vtable里根本没给T留位置，参数就丢掉了。

[jx-nan]

有大佬知道，这地方为什么要解引用吗？ *self ，感觉去掉也没问题
impl Display for FileState {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
FileState::Open => write!(f, "OPEN"),
FileState::Closed => write!(f, "CLOSED"),
}
}
}

[Gvhthon]

感觉可以跟面向对象中的的继承和多态来理解。
trait：就是定义一个父类。

impl Trait for 类型，就是子类继承父类。

默认实现：就是如果子类没有对父类的方法进行重构时，就会继承父类中定义的方法，此时如果用子类调用该方法，则 会 调用父类的方法。

特征约束：就是定义函数的时候，形参的类型是一个父类。则调用该函数的时候，必须传一个继承该父类的子类的实参。

多重特征约束：就是多重继承（好像是这么叫法吧，忘了），＜T：父类1+父类2＞，就是说实参必须是同时继承父类1和父类2的一个子类。

不知道对不对，大佬请指正😃

[DylanJinx]

fn largest<T: PartialOrd>(list: &[T]) -> &T {
let mut largest = &list[0];

for i in 0..list.len() {
if list[i] > *largest {
largest = &list[i];
}
}

largest
}

[vince-1998]

炸裂

[vince-1998]

炸裂

[gitbufenshuo]

impl<T: Display> ToString for T {
// --snip--
}

这个很费解，这段代码是官方库里的，但是能影响任何用户自定义的T。
也就是说，用户只要自定义了一个T, 实现了 Display 特征，那么编译器就自动帮这个T实现了ToString特征，也就是说，帮这个T添加了ToString特征里面的方法并给以实现？

那这些方法是怎么实现的呢？

[aksjfds]

应该是在你的代码编译前把这段代码塞了进去

[ZZH-Finalize]

对于有C++基础的同学, 我觉得可以这样解释
rust泛型 = C++模板
trait = c++ concept 和 带虚函数/纯虚函数的class
trait bound = c++ concept + requires
静态分发就是C++模板静态多态, 动态分发就是虚函数或者纯虚函数调用

rust对trait能同时实现静态和动态分发, 但C++实际上是对concept实现静态分发, 对虚函数/纯虚函数实现动态分发

[C4V1NC3MPT-196883]

关于Rust在设计特例化impl的动机不是很明白：

具体可参照Error code E0119

比如定义一个统一的trait K，那么：

impl<T: trait bound1> K for T
impl<T: trait bound2> K for T

会报错为confilcting impl... 即使trait bound1 和 trait bound2 是disjoint的

不知道Rust将来是否能支持如同cpp一样 按照trait继承关系给出安全特例化的impl用法

[CrazyChildren]

看起来rust的特征比go的interface麻烦挺多。
首先多态的表达需要特征对象，还有诸多限制。
其次需要显示声明impl某个trait才能当成多态使用，而不是只要方法实现了此trait声明的全部方法即可；

[yu244]

largest 不指定 Copy 特征 的实现，不知道对不对

fn largest<T: PartialOrd>(list: &[T]) -> &T {
    let mut largest = &list[0];

    for item in list.iter() {
        if item > largest {
            largest = item;
        }
    }

    largest
}