basic/trait/trait-object

[giscus[bot]]

basic/trait/trait-object

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

[giveahug]

看到这一脸懵逼

[blkcor]

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

[lgdu]

正在懵逼的路上。。。

[yuliang0225]

目前为止最抽象的吧

[ghost]

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

[Hello-world150]

昨天一遍，今天一遍，不懵逼了😉

[overlords]

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

[chanhsiaoyu]

重点太多啦 :)

[Hello-world150]

这个dyn到底是什么啊……

[typed-sigterm]

这个dyn到底是什么啊……

dynamic, 动态的

[Hello-world150]

谢谢🙏

[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 没看懂啊

[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的参数和返回值是什么。

[Laplace825]

尝试自己写了一个trait，感觉这里可能是这样的， 不过我也没求证过 Add 内的具体实现，希望有懂的大佬👻

// @note: 类似的Add特征
trait PAdd {
    type OutputPAdd;
    fn add(self, rhs: Self) -> Self::OutputPAdd;
}

#[derive(Debug, Clone)]
struct Point3d<T: std::ops::Add> {
    x: T,
    y: T,
    z: T,
}

// @note: 应该解读为为 泛型 Point3d<T> 实现 PAdd 特征，
// 而 T 这个类型要满足 std::ops::Add 特征
impl<T> PAdd for Point3d<T>
where
    T: std::ops::Add<T, Output = T>, 
    // 这里的Output就是Add这个特征里面定义的一个type
    // 类似PAdd的type
{
    type OutputPAdd = Point3d<T>;
    fn add(self, rhs: Point3d<T>) -> Self::OutputPAdd {
        Point3d {
            x: self.x + rhs.x,
            y: self.y + rhs.y,
            z: self.z + rhs.z,
        }
    }
}

fn main()
{
    let p1 = Point3d {
        x: 1.1f32,
        y: 1.1,
        z: 1.1,
    };

    let p2 = p1.clone();

    // 由于 + 本身是 std::opts::Add 特征的 add 函数实现,
    // 而我们实现的是 PAdd 特征，所以这里只能显式调用
    let p3 = p1.add(p2);
    dbg!(p3);
}

[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]
}

[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，能解释一下么？

[Blyzes]

list.iter()返回的是&T类型，&item时实际是&item与&T匹配，item的类型是T，改成item后item的类型就是&T了，可以复制到vscode中，观察修改前后自动推导的item的类型

[yangwenbing2]

哎，太难了，先看后面的，回头再来啃

[wugeer]

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

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

largest

}

[Ajingjing006]

有难度，确实有难度

[Elixin]

这为什么这么像接口类和抽象类

[eliassama]

懵逼树上懵逼果，懵逼树下你和我。😮

[ppinkpant]

学过java的泛型 看这节还是难度飙升

[petaleaf]

大家看看对不对，我降维举例一下那个特征作为函数参数，只有带有某种特征的参数才能作为那个函数的输入，比如着函数的功能是地铁站检查液体是否能带进去，那个检测仪就是函数，你只有具备液体这个特征才能被检测。

[Veng0923]

特针可以impl其他特征吗?

[zegzag]

trait 特性，接触过大数据 scala 语言的人就听过这个名词，包括模式匹配，真的modern的现代语言才会有这些特性。trait 特性真得很帅 (比 OOP不知道高到哪里去了)。使用现代语言后，就懒得搞 java、c++ 那些啰嗦又臃肿的故纸堆了。

[17998384]

”但是这种写法限制了 Screen 实例的 Vec 中的每个元素必须是 Button 类型或者全是 SelectBox 类型。“

这句话中的：”必须是Button类型“应该改为：”必须全是Button类型“才对；这个细节错误让我看了半天才理解

[boruns]

之前看官方文档不太清楚，这次完全理解了。

[boruns]

impl trait 和 dyn trait，分别是静态分发和动态分发，前者在编译时已经知道数据类型，后者不知道类型，所以一般使用智能指针来wrap一下，智能指针的大小一般都是确定的。

[17998384]

理解就好，另外静态分发我觉得就跟泛型差不多，比如说有个trait叫Animal，方法如下：

fn demo<T: Animal>(x: T) {
}

fn demo(x: impl Animal) {
}

泛型本身就是在编译期必须确定真实类型，impl trait也是在编译期确定真实类型，所以你看他俩是不是很像？而且文章里也提到了impl trait就是一种语法糖，所以我理解这玩意其实就是泛型

[fan-wb]

看完这部分感觉有点喜欢 rust 了🦀

[qy-tech]

这不就是更加灵活的Java 的接口吗

[drakedoglife]

关于最后一个例子的部分代码

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"),
     }
   }
}

这里为什么match后边的*self要加*来解引用，我试了去掉*号似乎也能跑通。

[drakedoglife]

self在特征中指的是实现它的那个对象，那么self在这里就应该指的是FileState。在fmt方法中第一个参数是&self，指的是借用FileState的所有权，那么在match中解引用所表达的值到底是什么呢？